How to Catch Up With AI-Assisted Programming

TL;DR

Developers can catch up with AI-assisted programming by testing leading coding agents on real tasks, reading their output, and learning where they succeed or fail. Use plan mode, compare generated solutions with work you already completed, and preserve difficult tasks as repeatable benchmarks. The goal is greater code output without lowering confidence in quality.

Transcript

I've never felt this much behind as a programmer. The profession is being dramatically refactored as the bits contributed by the programmers are increasingly sparse in between. I have a sense that I could be 10 times more powerful if I just properly string together what has become available over the last year. And a failure to claim the boost feels... Read More

Key Insights

• AI-assisted coding is already useful in daily professional work, according to the speaker, who reports that AI produces about 90% of his code and at least 70% of the code created by teams he runs.
• The programming profession is gaining a new abstraction layer involving agents, subagents, prompts, contexts, memories, modes, permissions, tools, plugins, skills, hooks, MCP, LSP commands, and workflows that developers must learn to combine effectively.
• The central goal is to increase code output without reducing confidence in quality. Achieving that goal requires developers to understand generated work, inspect implementation choices, and retain responsibility for evaluating whether results meet their standards.
• Plan mode is a useful entry point because it enables plain-English discussion similar to planning with a coworker at a whiteboard. It also lets developers observe how an agent explores a codebase, gathers context, and forms an implementation approach.
• Real project tasks are better capability tests than isolated demonstrations because they reflect the codebases, constraints, and quality expectations developers encounter every day. Increasing task difficulty gradually helps reveal where an agent remains dependable and where it becomes unreliable.
• Previously completed work is valuable evaluation material because the developer already knows how the task was solved. Comparing an agent's implementation with the original solution exposes differences in reasoning, code quality, completeness, and the amount of guidance required.
• Personal AI benchmarks can be created by restoring a repository to a point before a feature was implemented, saving the task description, and asking an agent to reproduce the work. Failed attempts can be archived and tested again after tools improve.
• AI agents can now build working applications rather than only mock interfaces. The example in the transcript is a functional image-generation studio with a backend, synchronization, file storage, image generation, a usable interface, and a working save button.

Questions & Answers

Q: How can programmers catch up with AI coding tools?

Programmers can catch up by selecting a current coding agent, giving it a real feature from an existing project, and pushing it until its limitations become visible. They should use plan mode when available, read the proposed plan and generated code, and judge the result against their normal quality bar. Repeating this process builds practical intuition about capabilities and weaknesses.

Q: Why does the speaker believe AI coding is no longer early?

The speaker believes the experimental waiting period has ended because AI now provides value in everyday software development. He reports using AI for about 90% of his own code, with teams he runs reaching at least 70% AI-generated code. He also points to developers using it for compilers, languages, systems, applications, and deployment infrastructure as evidence of practical adoption.

Q: What are the main goals of learning AI-assisted programming?

The two main goals are building an accurate intuition for what coding agents can and cannot do, and increasing the amount of code produced without decreasing confidence in its quality. These goals require more than accepting generated output. Developers must observe how agents investigate repositories, examine their plans, read their code, and determine whether each result satisfies established standards.

Q: How should developers test the limits of coding agents?

Developers should assemble authentic tasks from their own projects and present them to coding agents in order of increasing complexity. A delayed feature or a previously completed implementation can serve as the test. The developer should review the plan, inspect the output, adjust the prompt when the result is close, and record the exact areas where the agent becomes confused or incomplete.

Q: Why is plan mode useful for AI coding?

Plan mode is useful because it creates a plain-English exchange that resembles planning an implementation with a coworker at a whiteboard. Before code is changed, the developer can evaluate the agent's proposed approach and correct misunderstandings. Watching the agent explore the repository also shows how it gathers context, identifies relevant files, and reasons about the structure of the codebase.

Q: How can completed projects become personal AI benchmarks?

A developer can restore or clone a repository from the point before a known feature was implemented, place the original task description in a markdown file, and ask an agent to build it. Because the developer knows the successful human solution, the new result can be compared directly. This creates a relevant benchmark tied to real work and a familiar quality threshold.

Q: What should developers do when an AI agent fails a task?

When an agent gets close, the developer should revise the prompt and provide clearer guidance to see whether the implementation can be completed. If it still fails, the repository state, task description, and related materials should be saved together. The same case can then be tested again when models or tools improve, making changes in capability easier to observe.

Q: Does AI-generated code remove the need to read code?

AI-generated code does not remove the need for review in the workflow described. The speaker explicitly emphasizes reading the output while searching for the tools' limits. Developers still need to assess plans, inspect implementation choices, compare results with known solutions, and decide whether the work meets their quality bar. The objective is faster production without sacrificing confidence in correctness and quality.

Summary & Key Takeaways

• AI-assisted programming has moved beyond autocomplete and simple API scaffolding. The speaker reports writing about 90% of his own code with AI, while teams he runs reach at least 70% AI-generated code. He argues that adoption is now a professional responsibility because coding practices and the job market are changing.

• The first step is to test current coding agents on increasingly difficult, authentic development tasks. Developers should inspect plans, read generated code, and compare the results against their own quality standards. Plan mode is especially useful because it supports plain-English discussion while revealing how an agent investigates and understands a codebase.

• Previously completed features can become personal benchmarks for evaluating new models. Restore a repository to its earlier state, provide the original task description, and assess whether an agent can reproduce acceptable work. Save unsuccessful cases and retry them when tools improve, creating a practical record of capabilities, weaknesses, and progress.