Writing Code Is No Longer the Hard Part: Planning and Verification Are the New Bottlenecks

From Prompt to Production: Why Writing Code Has Become the Easy Part

Right now, getting from an idea to a live product has never seemed easier. You describe your project to an AI, and an agentic coding IDE immediately gets to work — from the first line of code all the way through to actual deployment. But what truly determines success isn't whether the AI can write the code. It's what happens before and after it does.

A widely shared technical talk has put forward a view that's gaining traction across the industry: as AI dramatically drives down the cost of implementation, writing code is becoming the easiest part of the entire software engineering process. What's genuinely scarce — and what truly determines quality — is what happens at the two ends: planning and verification.

Planning: The Quality of Your Solution Is Decided Before the First Line of Code

Just as you wouldn't pour concrete for a building without architectural blueprints, complex engineering work has to start with thorough planning. An effective AI workflow requires understanding intent, assessing impact, and reasoning through the right steps needed to complete a task. In other words, the quality of a solution is often determined before a single line of code is written.

A useful example illustrates this clearly: suppose you have a website and you ask an AI coding assistant to "help customers find information faster." The AI has many valid implementation paths — build a search bar, write an FAQ section, surface personalized recommendations, or create an AI chatbot. The AI can execute all of these with high quality and speed.

The problem is that each of these paths carries very different hidden constraints: maybe you don't have enough customer data for personalization, maybe you lack the budget for an AI assistant, or maybe your tech stack is missing the necessary licensing. The AI can execute — but only you, as the one providing the prompt, can define what success actually looks like and why.

Modern software development is increasingly less about writing code itself, and more about weighing dependencies, workflows, architectural decisions, and trade-offs within ever more complex systems. When AI makes implementation cheap, choosing the right direction becomes even more important.

Execution: The Code Change Is Just a Small Piece of a Much Larger Workflow

It's easy to think of a code change as a simple "prompt to code" loop — you or the AI write the code, commit it, done. But in reality, implementing a change is a far larger workflow, and the code change itself is often just a small part of it.

You may need to update code, tests, configuration, infrastructure, documentation, monitoring, pipelines, dependencies, security, and compliance — the list goes on. What makes this even more complex is that these updates frequently need to be coordinated across multiple repositories, services, and delivery pipelines.

The real value of an agentic coding system isn't that it can write a simple function — it's that it can chain execution, verification, dependency management, and testing into a unified workflow and coordinate across all of these domains on your behalf. And because they're agentic, these systems don't just act once: a coding agent will build, run tests, find failures, fix failures, run security scans, validate dependencies, then continuously re-evaluate and rebuild.

This creates a self-correcting workflow where execution and verification happen in parallel, together driving efficient outcomes. The real challenge has never been just generating code — it's coordinating all the changes that surround it.

---

Agentic coding systems differ fundamentally from traditional AI code completion tools in their autonomy and multi-step reasoning capabilities. Traditional tools (like early Copilot) operate primarily as "single-step suggestions": the developer types, the AI completes a line or block, and the process stops there. Agentic systems, by contrast, can autonomously break down tasks into sub-plans, invoke external tools (terminals, file systems, browsers, APIs), dynamically adjust their approach based on intermediate feedback, and iterate continuously until the goal is achieved. This "perceive–plan–execute–feedback" loop is the core meaning of the term "agentic." Representative agentic coding environments today include Cursor, Devin, and GitHub Copilot Workspace. These typically integrate code editing, terminal execution, test running, and version control operations, enabling AI to complete full engineering tasks across multiple tool boundaries in a single session — rather than simply generating an isolated code snippet.

---

Verification: AI Can Scale Execution Far Faster Than Humans Can Scale Verification

Even when an agent successfully completes a task, one question lingers: how do we actually know it worked?

For years, software development was constrained by execution speed — writing code, migrating systems, and running tests all took time. AI has changed that. Today, an agent can update hundreds of files, touch multiple repositories, and modify tests, pipelines, and configurations — all within minutes. That's output.

But a fundamental tension has emerged: AI scales execution far faster than humans can scale verification. If an agent changes 5 files, I can review them myself. But if it changes 500 files across multiple repositories, tests, and deployment pipelines, I simply cannot manually inspect every single change. When execution is no longer the bottleneck, our confidence in whether the outcome is correct becomes the new constraint.

As developers, we need clear answers to a few straightforward questions: What changed? Why did it change? What might it break? How does it affect downstream systems? And — did we actually achieve the goal?

One line from the talk cuts to the heart of it: "I don't care that the AI changed 1,000 lines of code. I care that it changed the right 1,000 lines, and that they move us closer to the outcome we need."

---

This tension maps directly onto a concept in software engineering known as the Verification Bottleneck. Traditional software engineering builds confidence in changes through code review, unit testing, integration testing, and static analysis — but the throughput of these mechanisms is inherently limited by human attention and time. When AI multiplies code output by an order of magnitude, these existing quality gates become the obvious constraint. This is precisely why both academia and industry are actively exploring "AI-assisted verification" — using another AI or formal methods to audit AI-generated code, creating a two-layer structure where AI writes and AI checks. Some teams are also adopting Change Impact Analysis tools that automatically trace how a commit propagates through call chains, dependency graphs, and downstream services — enabling rapid risk assessment without reading every line.

---

AI Shouldn't Just Produce Code — It Should Produce Evidence

When used correctly, AI shouldn't just generate code. It should generate evidence — backing up results through tests, validation, impact analysis, and explanation. And that evidence, in turn, becomes developer confidence in the outcome.

Trust doesn't come from seeing more output, and it doesn't come from someone simply telling you the answer. Trust comes from knowing that a solution actually works, understanding its implications and risks, and being confident that the goal has been achieved. The best AI workflows don't just accelerate execution — they accelerate confidence at scale.

From "Prompt to Code" to "Prompt to Production"

AI coding tools have come a long way in just a few years. Early on, they focused on generating code that ran. Today, agentic coding systems can embed themselves into the full software development lifecycle to simplify the hardest part: coordination.

As AI makes execution cheap, the skills valued in modern developers are shifting accordingly — from planning and architecture to governance, engineering judgment and critical thinking are more valuable than ever. We've already moved past the "prompt to code" era. What's ahead is "prompt to production." The most powerful AI workflows will connect planning, execution, verification, and validation into a continuous path from idea to outcome.