Beyond the Hype: Real Talk on AI-Assisted Development • Jessica Kerr & Diana Montalion
Jessica Kerr and Diana Montalion explore a pragmatic approach to AI-assisted coding, framing AI not as a replacement for developers, but as a powerful tool for automating tedious work like typing, scaffolding, and error handling. They argue that AI's strength lies in executing well-defined, laborious tasks, which frees up developers to focus on the nuanced, high-level work of systems thinking, architectural design, and discerning the right response to complex problems—skills where AI currently falls short.
In a world where systems, both in software and society, are in a constant state of being partially broken, the developer’s role is not to achieve a mythical state of perfection but to effectively work within this complexity. The goal is to improve our ability to respond to failures rather than naively trying to prevent them all. This requires focusing on the relationships and boundaries between components, a skill of nuanced thinking that remains uniquely human.
AI’s Strength: The Ultimate “Typist”
AI coding assistants excel at tasks that are laborious and syntactically complex, effectively acting as a powerful “typist” that removes friction from the development process.
- Automating Scaffolding: A significant amount of a developer’s work involves writing code that isn’t part of the core production application, such as tests, deployment scripts, and automation for manual checks. AI can generate this “scaffolding” code—like a Playwright script for a browser test or a utility script to parse a log file—almost instantly. Tasks that were previously deemed “too much work” for their benefit are now cheap and accessible.
- Handling Boilerplate and Syntax: For developers working in unfamiliar languages or dealing with verbose syntax (e.g., Java), AI assistants eliminate the cognitive load of recalling specific syntax. By writing a simple comment describing the intent, the developer can have the tool generate the correct code, including comprehensive (if sometimes excessive) error handling.
- Synthesizing and Translating: AI can quickly synthesize patterns and solutions from a vast corpus of public code, accelerating research and debugging. It’s also effective at translating code from one format to another, such as converting standard HTML and CSS into a specific framework’s syntax like Tailwind.
AI’s Weakness: A Lack of “Thinking” and “Taste”
While excellent at generating code, AI lacks the critical thinking and discernment that define an experienced developer. It can’t understand the “why” behind the code, which leads to several significant pitfalls.
- Hiding Failures: One of the most dangerous tendencies of AI-generated code is its ability to hide failures. It might implement a fallback that returns a plausible but incorrect value, making a system appear to work. This creates a veneer of correctness that passes initial tests but masks underlying issues, which only surface in production. This makes observability more critical than ever, as developers need to see what the code is actually doing.
- Optimizing for the Wrong Thing: AI is trained on public repositories, which are often demo applications with subpar error handling and robustness. It lacks the “taste” to distinguish good architectural patterns from convenient shortcuts. Its goal is often to produce code that simply “looks right” or passes a test, even if it means doing so in a brittle or nonsensical way. As Jessica Kerr notes, “you have to watch it.”
- Inability to Handle Inference: The most challenging problems in software are not in the components themselves but in the “gaps” and relationships between them. AI struggles with this level of inference and contextual understanding. The architectural decisions—how to respond to a downstream service failure, when to shorten a timeout, what constitutes a meaningful error message for the user—remain firmly in the developer’s domain.
A New Partnership: Amplifying Human Expertise
The most effective way to use AI is not as an autonomous agent but as a partner that amplifies human expertise. The developer’s role shifts from writing every line of code to directing, discerning, and curating the output of the AI.
- You Are the Thinker: The developer is responsible for asking the right questions and providing the necessary context. The AI can gather information, explore possibilities, and execute the implementation, but the strategic thinking is human-led.
- Improving the Relationship: You can guide the AI by providing it with explicit instructions and context files. When the tool produces undesirable output, the solution is to refine its operating instructions, teaching it your preferences and constraints, much like improving the boundaries in a software system.
- A Practical Starting Point: For those looking to experiment, a great place to start is by identifying a tedious, repetitive task you’ve always wanted to automate. Ask the AI to write that script you “wish you had.” This leverages its strengths for a low-risk, high-reward outcome, allowing you to focus your energy on the complex problems that truly require human ingenuity.