A coding agent will write a thousand lines before your coffee cools. Whether those lines become leverage or liability is settled before the run starts: how narrowly you scoped it, which rules you handed it, and who reads the diff. Working with coding agents is the developer question technical leaders bring to us more often than any other, and they arrive with the same three scars — a run that lost the plot, a bill nobody saw coming, and a usage limit that stopped the work mid-task.
Agentic Coding In Practice
How Do Engineering Teams Actually Work
With AI Coding Agents?
The four practices that survive a real codebase, what belongs in the rules file, why the spend moves, and where local hardware is still the weak option.
Built from real buyer questions in our sales meetings
Direct Answer
Four practices hold up under contact with a real codebase. Scope each run to one change on one branch. Keep a standing rules file in the repository that the agent reads at the start of every session. Review the diff the agent produced rather than its summary of what it did. Set the spend ceiling before you say go, because agent platforms do not price a run before execution — once it starts, it runs until the credits are gone.
The local option is the weak one here, and Iternal says so before you ask. Agentic coding on a small model running locally is only kind of usable today and not quite there yet. No model small enough to sit on an AI PC is good for code, and most machines lack the five to nine gigabytes of video memory the agentic model wants. AirgapAI chat is a day-to-day productivity assistant, which Iternal does not claim as an equivalent to the leading cloud coding agents — it carries none of the tool-calling loops those agents run on.
Model size decides whether local is on the table. Iternal measured a 27-billion-parameter class model on a dedicated GPU as good enough for agentic coding with its own coding tool: above what a typical laptop carries, within reach of a workstation GPU or a model served from your own data center. Test that on the machines your engineers carry, and settle the cost envelope with the questions below.
Treat local coding agents as the constrained case and enforce the practices everywhere. For real work today, most teams will run all four against a cloud agent. For more information on how agents chain, call tools and get governed, visit the agents, personas and skills page; for what tokens cost, visit the cutting token and inference cost page.
The Four Practices That Survive a Real Codebase
Every complaint engineers bring us about coding agents traces back to a control nobody set: the agent did not lose scope on its own, it was handed a task with no edges. Four controls answer the four failure modes:
| Practice | What it means inside a run | The failure it prevents |
|---|---|---|
| Narrow the scope | One change, one branch, stated up front. Ask for a recommended approach and approve it before implementation. | Runs that drift off task and blow past the context the agent holds. |
| Write the rules down | A markdown file of standing instructions in the repository, read at every session start. | Re-arguing your conventions, and duplicate components nobody asked for. |
| Review the diff | Read what changed on the branch, not the summary the agent wrote about itself. | Generated code entering the codebase unread. |
| Cap the spend first | A ceiling per run and per engineer, agreed before execution, plus a limit on agents per workflow. | Credits gone mid-task, and usage limits that stop the work without warning. |
Which Model Actually Codes — and What the Hardware Wants
Model choice matters more for coding than for anything else a local deployment does. A chat assistant answering from your documents tolerates a small model; an agent that plans, edits files, runs commands and reads the result back does not. Iternal puts the working threshold at a 27-billion-parameter class model on a dedicated GPU. Agentic runs grow the context window faster than chat, so memory demand runs ahead of parameter count, and a model larger than the dedicated video memory spills into system memory and slows sharply.
The shape that works today is a thin client on a fat model. AirgapAI Code, the terminal-native agentic coding platform Iternal ships, is built that way: a client-side installer that connects to a model wherever that model has room to run — a workstation GPU, a small local AI box, or an AI factory in your own data center — keeping the loop inside your network. It is model agnostic: any approved open-source model can be plugged in. Iternal expects a laptop-class model capable of reliable agentic coding within roughly six months, a forecast to plan against rather than a capability to buy.
The Rules File: Standing Instructions the Agent Reads Every Session
A coding agent starts every session with no memory of how your team works. The rules file fixes that: a markdown file kept in the repository, loaded at the start of each session, carrying the instructions you would otherwise repeat by hand. The filename differs between tools; the role does not.
What belongs in it are practices, not architecture. A good rules file makes no code or architecture decisions; it codifies best practice into a guided development cycle. Iternal built its own by analyzing months of real prompting sessions and keeping the instructions that survived:
- Check the existing components before creating a new one.
- Organize unit tests in nested folders by category and use case.
- Record in every commit note which feature the change covers.
- Commit only tested, working features, and commit before any major change.
- Ask clarifying questions before implementing, and wait for approval.
Then tell the agent to follow the rules file to the letter. Every agent that opens the repository inherits the conventions, and so does every new engineer.
What Coding Agents Cost, and Why the Number Moves
Engineering leaders describe the spend problem in near-identical terms:
- Agent platforms do not predict cost before execution, so once you say go it runs until the credits are gone.
- Hitting the usage limit forces an hour of waiting or a switch to another coding tool mid-task.
The range is the planning problem, not the price. One buyer put the month-to-month reality plainly: the same subscription might cost thirty dollars for one engineer and five hundred for another, depending on how hard they run it. Skill, not spend, decides the output. Scope the run, cap the agents a single workflow may launch, and keep whatever a model you host can handle off the metered path.
Iternal makes no money on your token spend, so the model and the provider stay your decision. A written answer settles the bill shape better than any estimate:
Pin it down: questions for your evaluation
-
Which model and GPU was the agentic coding threshold measured on, and can we repeat that test?Whether the model-size bar holds on the machines your engineers carry.
-
At our usage, what does a month of agentic coding cost per engineer?The spend range in writing, and whether work stops or degrades at the limit.
-
Can a hard ceiling be set per run and per engineer before execution starts?That the control is a setting rather than a habit, which is the whole difference for a finance team.
-
Which parts of our coding workload can run on a model we host, and which need a frontier model?Where the local path is a real option today, written down before you buy.
When the Agent Loses the Plot on a Real Codebase
The sharpest objection engineers raise is well founded: coding agents leave scope fast, exceed the context they can hold, and point at where a problem lives without writing the fix. Reading a codebase for the first time and reviewing one new feature on an existing codebase are different workflows, and an agent handed the first when it needed the second produces confident noise. Practitioners who use these tools daily put poor results down to direction rather than model capability.
Rein it in and make it iterate with you. Run an analysis pass before requesting any change. Require clarifying questions up front, which removes the guesswork about where the agent is lost. When output goes wrong, open a fresh session and paste the bad output in rather than arguing in place: a clean context keeps the model focused. Then check the work with a second model — Iternal builds fast with one agent and reviews with another.
Keep the commit human. Iternal declines to delegate it: work goes on a branch, takes a standard code review, and merges once a person signs it off. Committing before every major change leaves a working state to return to, and heads off the failure buyers describe — a whole application nobody can fix once it breaks.
Rolling Coding Agents Out to a Team
Two ceilings stop a rollout, and they need different fixes. The first is what the agent can see: projects tie to a single repository, so the tool suggests how a component should be used without knowing its props, because that component lives elsewhere; point it at the whole code folder instead and it drifts once context collapses. Both fixes are scoping fixes — name the repositories in play in a saved workspace file, and put a rules file in each subfolder of a monorepo.
The second ceiling is people, and it is the taller one. Most employees at large companies cannot use a coding agent today, because an education gap, an awareness gap and a technical gap stack on top of each other. Volume compounds it: more code is generated across projects than any human can review, and a review template run in one long context window skips its middle.
Sequence it. Start with the engineers already fluent, make the rules file the shared artifact so their practice travels, split large reviews into separate focused passes, and pair the reluctant with someone who has the habit. Iternal runs agentic coding training for this gap.
Answered elsewhere
- Which models are supported, and bringing your own — see choosing a local model.
- How agents chain, call tools and get governed — see agents, personas and skills.
- What tokens cost and bringing the bill down — see cutting token and inference cost.
- Using a local model as the engine behind your own software — see a local model as your backend.
- Connecting AI to the ERP, CRM and platforms you run — see wiring AI into the systems you already run.
FAQ
FAQ: Working With AI Coding Agents
Yes, with controls. The reported failure is always the same: the agent leaves scope fast and exceeds the context it can hold. So is the fix — scope each run to one change, run an analysis pass before requesting edits, and open a fresh session rather than arguing with a run that went wrong.
Practices, not architecture. A rules file is a markdown file in the repository that the agent reads at the start of every session. It carries standing conventions: check existing components before creating a new one, organize unit tests in nested folders by category, record which feature each commit covers, and commit only tested working features.
Because the platforms do not price a run before it executes. Once you say go, the agent works until the credits are gone, and buyers describe high cost with no visibility into what is being spent. The same subscription can cost one engineer around thirty dollars a month and another five hundred. Set a ceiling per run and per engineer before execution starts.
Bigger than a laptop usually carries. Iternal measured a 27-billion-parameter class model on a dedicated GPU as good enough for agentic coding with its own coding tool. Below that line, agentic coding on a small local model is only kind of usable, no model small enough for an AI PC is good for code, and most machines lack the five to nine gigabytes of video memory the agentic model wants.
Sequence it around two ceilings. The tool ceiling is visibility: projects tie to a single repository, so scope the workspace to the repositories in play and put a rules file in each subfolder of a monorepo. The people ceiling is larger, because most employees at large companies face an education gap, an awareness gap and a technical gap at once. Start with the engineers already fluent.
Yes — AirgapAI Code, the terminal-native agentic coding platform Iternal ships: a client-side installer that connects to a model on a workstation GPU, a local AI box or an AI factory inside your own network, keeping the loop off the internet. It is model agnostic, so any approved open-source model can be plugged in. AirgapAI chat is a separate day-to-day productivity product.
Prove It on One Repository
Pick a single repository this week. Write the rules file, scope the first run to one change on one branch, set the ceiling before you start, and read the diff yourself. That loop tells you more than any benchmark.