Skip to content

Knowledge base

Deliberate practice

Deliberate practice builds judgment with coding agents: start in a domain you can check, keep tasks and feedback loops small, practice daily on real work, and put friction back where the tool makes thinking optional.

Written by

Updated:

Getting Started 2

Our position. We expect the skill to take months of practice, not hours: reading diff shapes, noticing when the agent writes suspiciously much code, knowing when to trust and when to verify (opens in a new tab). Understanding beats using, so practice until you know why the agent produced its output.

Each habit protects one thing: your ability to tell whether the agent’s output is right. That ability is what you lose first when the agent does all the thinking.

What should a beginner practice first?

  • Pick a first domain where you would spot a wrong answer without running the code.
  • Validate after each small, scoped step, the opposite of the “total automation” failure.
  • Put friction back on purpose: remap the accept key, switch off file writes, or keep a day without AI.

How do beginners build judgment with an agent?

Teams that measure their own adoption converge on similar lessons. Rotational Labs reported three months into a six-month internal study across its team of six that the biggest early failure mode was the “total automation” pattern: junior engineers delegating everything to the agent, producing thousand-line prototypes that overwhelmed senior reviewers. What worked was the opposite: decomposing work into discrete, well-scoped tasks with human-in-the-loop validation after each step, and focusing the tools on debugging, unfamiliar APIs, test generation, and boilerplate rather than architectural decisions or core business logic; they even wired line-of-code counters into CI to flag sweeping pull requests, and found the tools most useful for beating the blank-page problem, letting people get past the initial paralysis of an unfamiliar language or framework (Rotational Labs - What We’ve Learned From 3 Months Living with AI Coding Tools (opens in a new tab)).

Where you point those first hours matters as much as the habits. A recurring beginner’s tactic is to start on a domain you already master, so you can actually judge the output instead of trusting it blind (When AI writes almost all code (opens in a new tab)). One practitioner pushes one rung further: building a minimal coding agent, roughly three hundred lines wrapped in a loop, is the move that converts you from a consumer of AI into a producer, and calls that the new fundamental knowledge, on the level of knowing what a primary key is; part of the same literacy is knowing that not all models are agentic, so reaching for the wrong one is like buying an off-road car to ferry passengers (How to build an agent (opens in a new tab), 15 January 2026).

The progression from there is deliberate: keep the feedback loop tight and the tasks small at first, then widen the loop and grant more autonomy only once you catch yourself rubber-stamping every suggestion, sandboxing the environment so that the autonomy is safe to give (Vom Coder zum Dirigenten (opens in a new tab), 2 December 2025).

Proficiency comes from deliberate practice, not exposure. Geoffrey Huntley observes that the people getting the most out of these tools are the ones who put in deliberate, intentional practice, treating a model like a musical instrument rather than writing it off on the first wrong note, and that an engineer whose only experience is one gnarled proprietary codebase has not really tried it (deliberate intentional practice (opens in a new tab), 4 June 2025). The lowest-effort form of that habit is a daily one: spend an hour every day pushing the tools at real work rather than toy questions, and make sure you are on the best model available rather than the faster default, since the gap between free-tier and frontier is enormous (Something Big Is Happening (opens in a new tab), 11 February 2026).

The counterintuitive warning attached to that is that letting the agent do all the thinking is how you learn least: the WEF calls this cognitive offloading and argues durable skill needs desirable difficulty, the productive struggle of effortful work beyond your comfort zone (WEF – New Economy Skills: Unlocking the Human Advantage (opens in a new tab), December 2025). Practice also carries concrete technique: grounding a request in a handful of examples, around five is the reported sweet spot, and asking the model to reason step by step lift output quality far more than politeness or prompt length (prompting for talent sourcing (opens in a new tab), 6 June 2025).

One discipline deserves singling out because the tool actively works against it: because AI follows your direction, it will build an elaborate, well-researched-looking case for a bad idea as eagerly as for a good one, so the practitioner move is to point it at your own plan as a structured devil’s advocate rather than only as a validator (Anthropic – The Founder’s Playbook: Building an AI-Native Startup (opens in a new tab), vendor).

Because the tool makes offloading so easy, effective learners deliberately reintroduce the difficulty. A senior AI engineer at E.ON describes engineering “anti-UX” into the workflow on purpose: remapping the accept-suggestion hotkey so it is not a single reflexive keypress, or disabling the agent’s file-write tool to force a manual copy-paste, all to keep critical thinking alive (building scalable apps with AI, E.ON talk (opens in a new tab), 26 June 2025). A Google engineer’s version is a standing “no AI challenge” so that critical-thinking skills do not evaporate (The AI-Native Software Engineer, Addy Osmani (opens in a new tab), 5 December 2025). Even inside a hands-on build, the discipline that separates a real builder from someone who tries a tool once and quits is reading every generated file for your own understanding as the agent works (forkcast multi-agent build-along (opens in a new tab), 7 August 2025).

The warning underneath all three is that reviewing is not the same muscle as writing: lean only on evaluation and you keep the capacity to judge code while slowly losing the capacity to create it (Industry synthesis – AI’s impact on the state of the art in software engineering in 2026 (opens in a new tab), 6 February 2026).

The Pragmatic Engineer’s workflow recommendations match: plan with the AI before letting it code, keep tasks small and start new sessions frequently because performance degrades as context grows, be concrete in task descriptions, maintain custom instructions as a natural-language configuration of the assistant, and use some form of file-based memory across sessions. Just as important is knowing when to quit: when you lose track of what the agent is doing, revert and re-approach rather than pushing on (The Pragmatic Engineer - Learnings from two years of using AI tools for software engineering (opens in a new tab)). That plan-first instinct has since hardened into named, copyable workflows. HumanLayer’s Research, Plan, Implement pattern runs each phase in its own session, one goal per session: a research pass documents how the code works today without proposing changes, a planning pass turns that into an explicit phased plan with success criteria, and only then does an implementation pass execute it, ideally so mechanically that watching it is dull (goose docs - Research, Plan, Implement Pattern (opens in a new tab)).

The goose documentation adds a continuity rule: when a session’s context fills, a written plan lets a fresh session resume exactly where the last stopped. The Elephant-Goldfish model turns that written plan into a test you can run: the Elephant is the heavily-prompted, context-rich session and the design document it produces, and the Goldfish is a brand-new zero-memory session; you feed the Elephant, then hand only the document to the Goldfish and ask it to explain the system, and if it cannot, the document is missing context, so you add it and repeat until it passes (Elephants, Goldfish and the New Golden Age of Software Engineering (opens in a new tab)).

Resources

Articles

Documentation

Papers and reports

Posts

Talks and videos