AI coding tools have no agreed best practice, so pick an autonomy level you can audit. Anthropic Claude Code, the terminal agent, and an IDE autocomplete sit at opposite ends of that scale, and both have defenders. The useful question is how much control you hand over.
AI coding tools: what the five workflows actually disagree about
AI coding tools differ mainly in how much autonomy the model gets and who keeps the mental model of the system. Five common workflows run from autocomplete you approve line by line to an agent loop that runs unattended until tests pass. Each one moves the review work somewhere else rather than removing it.
The framing comes from Andrej Karpathy, the researcher who popularised the term vibe coding, as an autonomy slider: a dial between the model suggesting a fix and the machine doing whatever it wants. That slider explains why the workflows below argue past each other. They have all chosen a different setting on the same dial.
The video behind this article is a Portuguese-language explainer from the channel mano deyvin, published 29 July 2026. It groups practitioners into five schools and argues that no school owns the answer. This article keeps that structure, checks each claim against primary sources, and separates what each workflow genuinely fixes from what it only postpones.
Autocomplete keeps you in the driver's seat, and that is the point
Autocomplete assistance remains the most conservative AI coding workflow: the model proposes, you accept or reject, and you write the connective code yourself. GitHub Copilot is the reference product here, and its own framing casts the developer as the pilot with the assistant alongside. Cursor, the AI-first code editor built on VS Code, supports the same pattern inside a full editor.
The argument for staying low on the dial is failure mode. Language models invent functions that do not exist and present them confidently. Reviewing every suggestion catches that before it reaches the codebase. The cost is throughput: you still type most of the code and read all of it.
This workflow is often described as outdated. It is not. Plenty of teams ship production software this way in 2026, usually where the codebase is regulated, unfamiliar, or expensive to break.
- You approve each suggestion, so hallucinations stop at the review step.
- The mental model of the system stays entirely yours.
- Throughput stays close to manual coding for anything beyond boilerplate.
Delegating to a terminal agent turns you into a reviewer
Delegated agent work means you stop typing most code and review what an agent produces. Claude Code, Anthropic agentic coding tool that runs in the terminal, is the product most associated with this workflow. The developer writes a prompt or a task and the agent edits files across the repository.
Supporters describe the split in blunt terms. One agent builder quoted in the source video says the agent writes roughly 70 to 80 percent of the code and he mostly commits. A more disciplined version is spec-driven development: write a specification first, then let the agent build against it.
Spec-driven work has a clear justification. A written specification is reviewable, versionable, and independent of whichever model you run. The code becomes a projection of the document, which is why the document deserves more care than the diff.
How DHH and antirez changed their positions on agent use
Two senior practitioners reversed course within about twelve months, which is why the debate feels unstable. DHH, the creator of Ruby on Rails, argued in 2025 that delegating coding felt like competence slipping away from his fingers. By 2026 he described starting each task with an agent and called manual coding tedious.
Salvatore Sanfilippo, known as antirez, wrote Redis and published a widely shared post in 2025 arguing against agents and in favour of writing code by hand. In early 2026 he reversed that position, adopted Claude Code, and named his approach automatic programming.
The reversal matters less as gossip than as evidence about the tooling. A strong opinion formed in 2025 was formed against weaker models. That does not prove agents are safe for your codebase, and it does not prove the critics were wrong at the time.
The handwriting school and the theory it protects
The handwriting school holds that the valuable artefact is the mental model of why a system works, not the code text. Peter Naur, a Danish computer scientist, argued this in his 1985 essay "Programming as Theory Building": a program is a theory held in the heads of the people who built it, and source code is a residue of that theory.
Naur's argument explains a specific failure. An agent can produce code without ever holding the theory, because the reasoning lived in a context window rather than in a person. When the system breaks at an awkward hour, nobody on the team can reconstruct why it was built that way.
Edmond Awad, a Google researcher, has described the resulting cost as a comprehension debt: a bill that does not arrive when incurred. The distinction antirez drew on his way to adopting agents is worth keeping. Using an agent with direction and quality criteria is automatic programming. Accepting whatever the machine emits is vibe coding.
Unattended loops trade review for API spend
The most automated workflow puts an agent in a loop and lets it retry until the test suite passes, often overnight with nobody watching. The source video credits this method to Geoffrey Huntley and links it to the Ralph Wiggum technique, named after the Simpsons character. The pitch is a software cost below a fast-food wage.
The economics deserve scrutiny. An unattended loop spends tokens on every failed attempt, and the spend is metered whether or not the loop converges. A cost-per-hour figure for API usage is not the same as the cost of a working feature, and it says nothing about the review the result still needs.
Even practitioners enthusiastic about agents tend to reject the pure loop. Tests define the target, so a loop optimises against your tests rather than your intent. If the tests are thin, the loop will reach green by whatever route works.
Choosing your position on the autonomy dial
Pick the workflow by the failure you can detect fastest, not by the demo that looked impressive. Autonomy is a spectrum, and each step up it moves effort from writing to reading and reviewing. The table below compares the five positions on the dimensions that change the decision.
| Workflow | Example tool | Who holds the theory | Main failure mode |
|---|---|---|---|
| Autocomplete | GitHub Copilot | Developer | Slow throughput |
| Delegated agent | Claude Code | Shared, at risk | Unreviewed drift |
| Spec-driven agent | Claude Code | Specification | Stale specification |
| Handwritten | None | Developer | Slower delivery |
| Unattended loop | Custom loop | Tests only | Green tests, wrong intent |
A practical rule: raise autonomy only where you have a fast, trustworthy check. Strong test coverage, a small diff surface, or a low-stakes script justify more delegation. An undocumented legacy service justifies less, because your ability to catch a wrong answer is exactly what is missing.
Learning to code when the agent writes most of it
Using AI to learn to code works when the model explains and quizzes you, and fails when it replaces the practice. A reader who asked why learn programming when Claude Code knows everything got a fair answer in the source video: if the tool knows everything you know, nobody needs you in particular.
The skill that survives is discrimination. You need to look at generated code and see where it is hallucinating, where it silently skipped a requirement, and where it solved the wrong problem. That ability comes from having built and broken things yourself.
There is a reasonable case that this is a good moment to start. Free explanations, worked examples, and patient tutors are easier to find than at any earlier point, and the barrier to shipping a first working prototype is lower. The trap is treating that tutor as a substitute for the work rather than a companion to it.
FAQ
- Are AI coding tools replacing developers? No current evidence shows that. The measured shift is in where effort goes: less typing, more reviewing and specifying. Practitioners quoted in the source video still describe review as the binding constraint.
- Is autocomplete with GitHub Copilot obsolete? No. Autocomplete remains a defensible choice where a wrong suggestion is expensive or the codebase is unfamiliar. It trades speed for a review step that catches hallucinations early.
- What is the difference between automatic programming and vibe coding? Automatic programming gives the agent direction, quality criteria, and a specification you understand. Vibe coding accepts output without building the theory behind it. The distinction came from antirez when he adopted Claude Code in 2026.
- Can an overnight agent loop replace code review? Not reliably. A loop that runs until tests pass optimises against your tests. Thin tests let it reach green without matching intent, and token spend grows with every failed attempt.
Turn a recorded explanation into a written article
Explaining how five competing workflows differ is easier to say than to write down, which is why the source video worked as a spoken argument. If you already have that kind of explanation recorded, the structure and the examples are sitting in the video already.
Skala Blog takes a YouTube URL, transcribes the video, and generates a draft article you can edit. The argument you made out loud becomes a draft with headings, sections, and an FAQ you can revise before publishing.