标签：#software

In 1994, Peter Deutsch published the Fallacies of Distributed Computing — eight assumptions that every developer building distributed systems makes, discovers are wrong, and pays for in production. The network is reliable. Latency is zero. Bandwidth is infinite. Each assumption sounds true. Each leads to system failures that could have been avoided. Thirty years later, we're making the same category of mistakes with generative AI. The trough of disillusionment for AI-assisted development has begun. Byron Cook, VP and Distinguished Scientist at Amazon, founder of AWS's Automated Reasoning Group (300+ scientists, 15+ teams), says it plainly: "Generative AI is sliding into the trough of disillusionment." The headlines are shifting. The "summer of vibe coding" is over. The disillusionment isn't caused by AI being useless. AI-assisted coding delivers real productivity gains. The disillusionment is caused by false assumptions about WHERE the gains come from and WHAT changes when generation gets fast. Teams expected 10x engineering. They got 10x code generation and 1x everything else. The gap between expectation and reality is the trough. This series names the eight assumptions, explains why each one fails, and presents the resolution — not from theory, but from domains that hit the same wall and climbed out. The Eight Fallacies 1. Faster code generation means faster engineering. You made one sub-system 10x faster. Seven others didn't change. The system doesn't get faster — it breaks at the interfaces. The CPU-memory wall tells you exactly what happens and what fixes it. 2. If the output looks correct, it is correct. AI-generated code is optimized for plausibility, not correctness. It compiles, passes tests, and reads well — while violating properties nobody tested. Plausible is not correct. The gap is where production failures live. 3. You can verify AI output with another AI. Guardrails, LLM-as-judge, AI code review — the verifier has the same failure modes as the thing

The conversation about cognitive debt in AI-assisted development has been framed as a tradeoff: you can go fast, or you can understand your system, but not both. The proposed mitigations — pair programming, code reviews, requiring a human to understand each change — are braking mechanisms. They trade speed for comprehension. TRIZ (Theory of Inventive Problem Solving) says braking is a compromise, not a resolution. A resolved contradiction eliminates the conflict. You don't choose between speed and understanding. You restructure the system so they don't conflict. There are six root causes of cognitive debt in AI-augmented development. Each one is a contradiction. Each one has a TRIZ resolution that doesn't involve slowing down. Root Cause 1: The Velocity-Comprehension Gap AI generates complex logic in seconds that would take a human hours to write. The human never spends the time typing the code during creation. The theory of the program is never fully formed. The Contradiction Technical contradiction: Improving development speed (AI generates code faster) worsens depth of understanding (human doesn't internalize the logic). Physical contradiction: The development process must be simultaneously FAST (to capture AI's productivity gains) and SLOW (to allow human assimilation of the system's behavior). Resolution: Separation in Space (Principle 2 — Extraction + Principle 1 — Segmentation) The contradiction assumes that the thing being understood IS the code. Extract the understanding target from the code and put it somewhere else — a smaller, slower-moving, human-readable artifact that captures what the code must satisfy, not how it works. Segment the system's theory into independent, composable units. Each unit is one property: "this service must never accept unauthenticated requests," "this data pipeline must preserve ordering," "this retry loop must terminate within 30 seconds." Each property is 1-3 sentences in natural language or 3-10 lines in a predicate language.

I understand why so many people are questioning software engineering right now. Every week there’s another headline saying AI will replace developers. Junior engineers are worried there won’t be jobs. Senior engineers are wondering how long their experience will stay valuable. And honestly, if you spend enough time on tech Twitter or LinkedIn, it can start feeling like the industry is collapsing in real time. But after using AI heavily in my day-to-day work as a software engineer, I’ve started seeing things differently. AI didn’t make me feel less useful. It made me feel more capable. Before AI became part of my workflow, a lot of engineering time disappeared into things that were mentally draining but necessary: repetitive refactoring debugging small issues writing boilerplate digging through documentation trying to remember syntax cleaning up legacy code writing SQL queries optimizing simple functions translating vague tickets into technical tasks None of these tasks were impossible. They were just time-consuming. Now, a lot of that friction is reduced dramatically. One of the biggest changes I noticed was backlog cleanup. Tasks that used to sit untouched because nobody wanted to deal with them suddenly became manageable. Not because AI magically solved everything. But because it helped reduce the “mental startup cost” of difficult tasks. Sometimes all you need is: a starting point a refactored example help understanding unfamiliar code a faster debugging path quick documentation summaries That momentum matters more than people realize. A task that feels overwhelming at 9AM suddenly becomes achievable when AI helps break it down. I also noticed we started delivering faster as a team. Not in a “replace developers with AI” kind of way. More in a: less context switching faster research quicker prototyping fewer hours stuck on repetitive problems better ticket breakdowns improved communication kind of way. The interesting part is that AI didn’t just help with coding.

Something broke in the AI pricing market between January and May 2026. A year ago, "frontier model" meant "expensive model." Claude Opus was $15/$75 per million tokens. GPT-4 was $5/$15. If you wanted the best coding performance, you paid the best price. The correlation between quality and cost was loose, but it existed. That correlation is gone. The Numbers That Changed Everything Here's SWE-bench Verified — the benchmark that tests AI models against real GitHub issues from projects like Django, Flask, and scikit-learn — plotted against output price per million tokens: Model SWE-bench Output $/1M Score/Dollar ───────────────────────────────────────────────────────────────── Claude Opus 4.7 87.6% $25.00 3.5 Claude Opus 4.6 80.8% $25.00 3.2 Gemini 3.1 Pro 80.6% $15.00 5.4 GPT-5.2 80.0% $10.00 8.0 DeepSeek V4 Pro (Max) 80.6% $3.48 23.2 Kimi K2.6 80.2% $4.00 20.1 Qwen3.6 Plus 78.8% $3.00 26.3 MiniMax M2.5 80.2% $1.20 66.8 DeepSeek V4 Flash (Max) 79.0% $0.28 282.1 Read that last line again. DeepSeek V4 Flash scores 79% on SWE-bench at $0.28 per million output tokens. Claude Opus 4.7 scores 87.6% at $25.00. The performance gap is 8.6 percentage points. The price gap is 89x . For a team running 100 million tokens per month, that's the difference between $28/month and $2,500/month. For a 9-point improvement in code completion accuracy. It's Not Just One Outlier This isn't a DeepSeek anomaly. Look at the cluster of models scoring 78-80% on SWE-bench: DeepSeek V4 Pro : $3.48/1M output — open source, 1M context Kimi K2.6 : $4.00/1M output — open source, 256K context MiniMax M2.5 : $1.20/1M output — open source, 200K context Qwen3.6 Plus : $3.00/1M output — open source, 1M context MiMo-V2-Pro : $3.00/1M output — open source, 1M context Five models from five different Chinese labs, all scoring within 2 points of GPT-5.2 ($10.00/1M) and Gemini 3.1 Pro ($15.00/1M), all at 1/3 to 1/10 the price. And they're all open source. What Happened Three things converged: 1. Mixture-of-Exper

“I don't want recommendations! I know what I want to watch."

Over the weekend, I attended an event hosted by Cursor Kenya, bringing together developers, builders,...

Over the past few years, my workflow as an engineer has changed a lot. I went from the occasional...

We are committed to empowering every developer by building an open, secure, and AI-powered platform that defines the future of software development. The post GitHub recognized as a Leader in the Gartner® Magic Quadrant™ for Enterprise AI Coding Agents for the third year in a row appeared first on The GitHub Blog .