AI Accelerates Software's Easy 70%, Magnifying Difficulty of Last 30%

The last 30% of software development is no longer about brute force coding, but about intentional design and nuanced orchestration. This conversation with Amelia Wattenberger, designer at Augment Code, reveals a critical shift: as AI agents automate the mundane, the true challenge for developers becomes navigating the complex, often overlooked, final stages of creation. This is essential reading for engineers, product managers, and leaders who want to understand how to leverage these new tools not just for speed, but for strategic advantage and genuine innovation. It offers a framework for thinking about the future of software development, moving beyond mere code generation to a more deliberate, design-led approach.

The Illusion of Completion: When Agents Accelerate the Easy Part

The current wave of AI agents has fundamentally altered the developer experience, primarily by accelerating the initial phases of software creation. Amelia Wattenberger, with her background at GitHub Next, has witnessed this evolution firsthand. What once took significant effort--writing boilerplate code, setting up basic structures--can now be achieved with a well-crafted prompt. This rapid advancement of the "easy" 70% of a project, however, creates a deceptive illusion. The perceived speed-up compresses the timeline for initial progress, but it simultaneously magnifies the difficulty of the remaining 30%: the polish, the craft, the nuanced integration, and the strategic design decisions that truly define a product.

This shift has profound implications for how we perceive value and progress. The ease with which agents can generate functional, albeit rough, prototypes encourages the initiation of more projects. This leads to a phenomenon of "software hoarding," where developers accumulate numerous half-finished ideas because discarding the AI-generated output feels wasteful, even if it doesn't align with the ultimate vision. The challenge, as Wattenberger articulates, is that this rapid prototyping capability, while empowering, makes the subsequent stages--transforming a functional prototype into a polished, user-centric product--feel disproportionately harder. This isn't just about aesthetic refinement; it's about embodying intent, making deliberate design choices, and ensuring the software truly serves a purpose, rather than just existing.

"The 70% has been squished into you know 10% of the project and then that last 30% is actually really hard now because we're starting all these new things... it makes other parts feel a little bit harder."

-- Amelia Wattenberger

The conventional linear view of project completion--where the effort is evenly distributed--is shattered. The value proposition for developers is shifting from being masters of implementation to becoming orchestrators of AI and designers of intent. This requires a new set of skills and a different mindset, one that embraces the difficulty of finishing and prioritizes thoughtful creation over sheer volume of output. The competitive advantage lies not in building more, faster, but in building the right things, with a deep understanding of their purpose and a commitment to their final form.

The Workspace as a Primitive: Taming Agentic Chaos

One of the most significant challenges emerging from the proliferation of AI agents is managing their interactions and ensuring coherent, purposeful output. The traditional development workflow, a fragmented collection of Slack conversations, issue trackers, and local IDEs, becomes even more unwieldy when multiple agents are involved. Amelia Wattenberger's work at Augment Code, particularly with their product "Intent," directly addresses this by proposing a new core primitive: the workspace. This concept moves beyond the idea of agents operating within chat threads or even individual work trees, advocating instead for isolated, task-specific environments where agents can collaborate effectively without stepping on each other's toes.

The tension between "one worktree per agent" and "one worktree per task" is a crucial design consideration. While an agent-per-worktree model offers clear isolation, it can hinder collaboration on related sub-tasks. Intent's approach of a "one worktree per task" model, where multiple agents can operate within the same isolated environment and are aware of each other's activities, allows for more natural collaboration. This is particularly important when tasks are inherently linked, such as an agent working on API changes concurrently with an agent modifying the UI that consumes those APIs. Visibility and communication between agents within a workspace are paramount, mirroring how human teams function.

"The proposal is just like, let's have a new primitive which is a workspace where everything lives so that it's easy for me to put down and pick up and hand off and share."

-- Amelia Wattenberger

This workspace paradigm is essential for managing complexity and fostering trust. When agents are aware of each other's actions, they can avoid conflicts, and developers can have a clearer understanding of who is doing what. The introduction of specialized agent roles--coordinator, implementer, verifier--further refines this process. A coordinator agent can delegate tasks, oversee progress, and ensure that the output meets specifications, while verifier agents can provide an independent check, building confidence in the AI's work. This structured approach to agent collaboration is not just about efficiency; it's about building a system that developers can trust and effectively manage, allowing them to focus on higher-level design and intent.

The Art of Restraint: Choosing What Not to Build

The advent of AI agents capable of generating substantial amounts of code and functionality presents a unique challenge: the temptation to build everything. With the perceived cost of implementation drastically reduced, the backlog of potential features and projects can seem to vanish overnight. However, as Wattenberger emphasizes, this abundance creates a new dilemma. The true skill in this agent-first world is not about maximizing output, but about exercising restraint and making deliberate choices about what to build. Shipping everything dilutes a product's identity and purpose, making it stand for nothing.

This shift requires developers to cultivate a new muscle: the ability to say "no" to features, even when they are easily achievable. The value of a product increasingly lies in its focused intent and its ability to solve specific problems exceptionally well, rather than its breadth of functionality. The conversation highlights how tools like Notion, which historically focused on documents, are now integrating AI to manage higher-level representations and summaries. This mirrors the evolution of development tools, moving from managing code primitives to managing the meta-level of intent and purpose.

"It's almost becoming the question is what you don't build as opposed to what you do build... the answer can't be ship everything... because then your stuff, it doesn't stand for anything."

-- Amelia Wattenberger

The implication is that the "last 30%"--the polish, the strategic decisions, the intentional design--becomes the differentiator. This is where human taste, judgment, and a clear vision are irreplaceable. Developers who can effectively leverage AI to handle the heavy lifting of implementation, while reserving their own cognitive energy for high-level design, strategic prioritization, and the difficult choices about what not to build, will be the ones who create truly impactful and enduring software. This requires a conscious effort to move beyond the immediate gratification of generated code and focus on the long-term vision and purpose of the product.

Key Action Items

• Embrace the "Last 30%": Prioritize the polish, craft, and strategic design elements that AI currently cannot replicate. This is where true product differentiation lies.
• Adopt Workspace as a Primitive: Experiment with tools that offer isolated, collaborative environments for agents (e.g., Augment Code's Intent). This is crucial for managing agentic workflows and ensuring coherent output.
• Define Agent Roles: Clearly delineate responsibilities for agents within a workspace (e.g., coordinator, implementer, verifier) to improve collaboration and trustworthiness.
• Practice Intentional Restraint: Actively choose what not to build. Focus on a core set of features that align with your product's purpose, rather than succumbing to the temptation of shipping everything.
• Develop Your "Taste" Muscle: Cultivate your unique design sensibilities and critical judgment. Use AI as a tool to explore possibilities, but rely on your own discernment to guide the final product.
• Explore Multi-Agent Orchestration (Longer Term): Investigate how multiple agents can work together on complex tasks, understanding the trade-offs between task-based and agent-based worktrees. This pays off in 12-18 months as agent capabilities mature.
• Leverage Enhanced Prompts (Immediate): Utilize features that expand initial prompts into detailed specifications. This helps clarify intent and reduces ambiguity before implementation begins.