Agentic coding has a marketing problem: the loudest examples are the least representative. A demo writes a whole app from one prompt. Your job is a payments bug in a repo with opinions. Almost everything useful about agentic coding lives in the gap between those two scenes.
After a year of running agents daily, and building a workspace for them, these are the principles we would hand to a team starting today. They are workflow rules, not product features. They work with any agent.
It is a workflow, not a model
The confusion starts with the word agentic. It does not describe the model; it describes who holds the wheel: the agent decides which files to read, which commands to run and when to stop, inside limits you set. Your job shifts from writing every line to defining tasks, constraining them, and reviewing judgment.
That is why two people on the same model get wildly different results. The difference is workflow: the size of the tasks, the isolation, the review discipline.
Five principles that separate shipping from fighting
1. One task per agent
Fix the auth redirect and also update the docs and also bump the dependencies is three tasks wearing one prompt. The agent will do task one with excellence, task two with fatigue and task three twice. One agent, one task, one branch, and you get three reviewable diffs instead of one confusing one.
2. Isolate before you parallelize
The moment two agents share a checkout, you are running a race and calling it a team. One git worktree per task is the convention for a reason: it is cheap, it uses plain git, and it removes the entire class of collisions. Our worktree guide has the mechanics.
3. Review diffs like a colleague's PR
An agent that writes 800 lines quickly has not saved you work; it has moved your work to review, where it is harder. The useful habit: make the agent show its plan before it edits, keep diffs small, and review them with the same skepticism you would apply to an intern's pull request. Trust is earned per diff, not per session.
4. The repository is the source of truth
Agents are only as good as what is written down: tests, types, lint rules, a clear module layout, commit messages. Every practice your team already respects pays compound interest when agents run, because it is the difference between constraints and guesses.
5. Budget attention, not tokens
The capacity that runs out first is yours. Three sessions you can genuinely supervise beat ten you have to check on. Plan the afternoon around how many diffs you can review well, and let the machine wait instead of you.
The failure modes to expect
Most bad weeks with agents follow one of four scripts. Knowing them makes them cheap:
- The confident detour. The agent misreads an assumption and builds a beautiful solution to the wrong problem. The plan-first habit catches this in two lines.
- The zombie session. It is waiting for a permission prompt you never saw. If your setup does not surface waiting sessions, you find out an hour later. Notifications exist for this.
- The merge tangle. Ten branches, none merged, main drifting. Parallel agents did their jobs; the merge pipeline is what failed. Merge on the day you review.
- The context sprawl. One session, seventy turns, arguing about something decided forty turns ago. Start a fresh task; a session is not a backpack.
01
[ Repos ]
The projects you already work on. No imports, no new home for code.
02
[ Worktrees ]
One isolated checkout per task, so parallel agents cannot collide.
03
[ Agents ]
Claude Code, Codex, opencode, anything with a CLI. Side by side, not either/or.
04
[ Machines ]
This laptop, a workstation, a server. One tree, real terminals.
Where the tools fit, honestly
Nothing above requires buying anything. A terminal, git worktrees and the agent CLIs are enough to start, and plenty of people stop there happily.
What a workspace adds is the part terminal tabs do not scale to: sessions that survive restarts, isolation that is a tree instead of a naming convention, one searchable history across Claude Code, Codex and opencode, and one place where status and usage are visible. That is the ADE idea, and it is what Leon is: a 23 to 27 MB native app, Apache-2.0, running any of 43 built-in agents on macOS, Linux and Windows.
Your first week
- Day one: one agent, one real task, one worktree. Read the diff. Change nothing else about your habits.
- Day two: write a bad task and a good task for the same change. Notice what task size does to the diff.
- Day three: run two sessions on two unrelated tasks, with a rule for spotting which is waiting on you.
- Day four: make review the queue. Merge or close everything finished before starting anything new.
- Day five: decide what the setup is missing, and add exactly that: a naming convention, a worktree script, or a workspace.
Agentic coding rewards boring discipline more than any model upgrade. Start there; the models will keep arriving on their own.