You have heard, from a nephew or a vendor or a podcast, that AI now writes software. You have also been quoted six figures and four months for an internal tool that, as far as you can tell, is a form and a database. Those two facts do not sit together, and nobody has explained why.
The phrase behind the first fact is agentic coding. It is real, it is not magic, and it has changed what custom software costs and how it should be bought. It has not changed who is responsible when the software is wrong.
This article explains what agentic coding actually is, what it does well, where a senior engineer is still the whole difference, and what that means when you are the one signing the purchase order.
What this actually is
Ordinary code assistance, which has existed for a few years, is autocomplete. A developer types and the tool suggests the next few lines. The developer stays in the driver’s seat the whole time.
Agentic coding is different in kind. You give the tool a goal in plain language (“add a page where a customer can see their open invoices and pay one by card”). The tool then plans the work, reads the existing codebase to understand how it is built, writes or changes the necessary files, runs the tests, reads the errors, fixes them, and comes back with a finished change for a person to review. The word “agentic” means it takes actions in a loop, on its own, until it decides it is done or gets stuck. An “agent,” in this context, is any AI system that can act rather than just answer.
The business analogy is the difference between a dictation service and a junior associate. A dictation service types what you say. A junior associate takes your instruction, reads the file, drafts the letter, checks the precedent, and puts a finished draft on your desk. You still read the draft before it goes out. But you did not have to type it.
Under the hood, the tool is a large language model (an LLM, the kind of AI that reads and writes text) given the ability to read files, edit files, and run commands on a computer. That is the whole trick. The tools in this category include Claude Code from Anthropic, OpenAI Codex, Cursor, and GitHub Copilot in its agent mode; we compare them in Claude Code vs Cursor vs Copilot: What Each Tool Is For.
What changed in 2025 and 2026
Three things moved at once. The models got much better at holding a large codebase in mind and reasoning through multi-step changes. The tooling matured, so an agent can now run a test suite, open a browser, and check its own work. And the working pattern shifted: one developer now directs several agents and spends the day reading, deciding, and correcting rather than typing.
The result is that a competent engineer with these tools produces working software much faster than in 2023. How much faster depends on the task, and anyone who gives you a single multiplier is selling something. But the direction is not in dispute.
What agentic coding does well, and where the engineer still decides
Levelbrook uses agentic coding heavily in everything we build, always with senior-engineer review. These are the rules that experience has taught us.
1. It is excellent at the parts that were always mostly typing
A large share of any custom system is well-understood plumbing: a login screen, a data table with sorting and filters, a form that saves to a database, a PDF export, an email notification, a connection to Stripe or QuickBooks. This work is not intellectually hard. It is long, fiddly, and easy to get subtly wrong. An agent does it quickly and, when the instructions are clear, does it well.
This is where most of the cost of custom software used to go, which is why the cost has moved so much.
2. It is only as good as the instruction, and the instruction is the hard part
An agent given “build me a CRM” produces a generic CRM that fits nobody. An agent given “a lead has these seven fields, these three people can edit it, a lead older than 14 days without contact turns red, and nothing is ever deleted” produces something your team can use on Monday.
Writing that second instruction requires someone who understands your business and understands software well enough to know what has to be said. This is what a senior engineer is for now: not typing, but deciding what to type. The agent has no idea that your dispatchers hate the current screen because it takes four clicks to reschedule a job. Someone has to find that out and write it down.
3. It makes confident mistakes, so everything gets reviewed
A model does not know when it is wrong. It will write a date calculation that fails at month end, a permission check missing on one screen out of nine, or a payment flow that charges twice on a double-click, and describe each as complete and tested.
The fix is not to stop using agents. The fix is a review step by a person who knows what to look for, on every change, before it reaches you. In our practice nothing an agent writes reaches a customer’s system without a senior engineer reading it. Ask any vendor how their review works. If the answer is “the AI tests it,” keep looking. The wider discipline of checking AI output before it goes live is the subject of AI Evaluation and Evals: Testing an AI Feature Before Launch.
4. Tests are what make the loop safe
An agent that can run tests can check its own work. A codebase with no tests forces the agent (and the reviewer) to guess whether a change broke something elsewhere. This is why good agentic work often starts by writing tests before the feature. You do not need to read tests. You need to ask whether they exist and whether they run automatically on every change.
5. The agent needs the whole picture, so documentation matters again
Agents read the codebase before they act, and they read whatever notes are left for them: how the project is structured, what conventions to follow, what must never be touched. A codebase with a clear written map gets better results from an agent than one without, in the same way a new hire with a good onboarding document outperforms one who has to guess. Insist that the notes exist and that they come with the software. They are part of what you own.
6. Integration is still where the time goes
Connecting to your accounting system, your phone provider, or your industry’s specific software is not made easy by agentic coding. The agent can write the connecting code fast, but it cannot read the other vendor’s undocumented behavior, cannot get you an API key (a password-like credential that lets one program talk to another), and cannot know that the “customer ID” in one system is the “account number” in the other. That is discovery and judgment, and it is a human job. For a longer discussion of what got cheaper and what did not, see The Cost of Custom Software in 2026 After Agentic Coding.
7. Security is a review job, not a generation job
Agents write plausible code, and plausible code is often insecure in ways that look fine: a field that accepts any input, a file upload without a size limit, a report that any logged-in user can open. These are caught by a reviewer who knows the list of things that go wrong. When your vendor describes the process, listen for whether security review is a named step.
8. Ownership is the thing to protect
Because the software is now cheap to produce, the temptation is to treat it as disposable. Resist that. The valuable part of a custom system is the encoded knowledge of how your business works: the rules, the edge cases, the reasons. That lives in the code, the tests, and the notes, and you should own all three outright, in accounts you control. The right question for any vendor is the one you would ask any builder: if you disappeared tomorrow, could someone else pick this up.
9. Speed changes how you should buy
With agentic coding, a first working version of a small tool can appear in days, so the smart way to buy is to scope small, see something real early, and adjust. The trap on the other side is a vendor who uses speed to skip the thinking. The scope should still be written down before work starts, even if it is two pages instead of forty.
Picture a business like this one
The business below is a composite of the kind of company that writes to us, not a client. The numbers describe the shape of the problem, not a case study.
Picture a business like this one: a regional HVAC contractor with 35 staff, six trucks, and a dispatcher who runs the day from a whiteboard and a spreadsheet. The owner has been quoted a custom dispatch and job-tracking system twice. The first quote was well into six figures with a four-month timeline. The second was a subscription to an industry platform that forced a workflow the dispatchers refused to use.
A shop like this, working with a developer who uses agentic coding properly, starts with a week spent with the dispatcher, not at a keyboard: what the whiteboard columns mean, what happens when a tech calls in sick, which customers get priority and why. That produces a written scope of a few pages.
From that scope, the build might look like:
- A job board that mirrors the whiteboard columns, with drag-and-drop, built and reviewed in the first few days.
- A technician view on a phone that shows today’s jobs and lets a tech mark arrival, completion, and parts used.
- A text message to the customer when a tech is on the way, through Twilio.
- A nightly export of completed jobs with parts and labor to QuickBooks.
- Tests for every rule the dispatcher described, so a future change cannot quietly break the priority logic.
The agent writes most of the code. The engineer writes the scope, reviews every change, tests the QuickBooks connection against the real account, and catches the two places where the model got a rule wrong. A first working version exists in weeks, the dispatcher runs it alongside the whiteboard for a fortnight, and corrections are made in days rather than as a paid “phase two.” The tool fits the shop instead of the reverse, and the software and its notes sit in a repository and a hosting account the business owns.
What it costs to run
Agentic coding changes the cost of building, not of running. Once the software exists, its running costs are the ordinary ones.
A small web application for a business this size typically runs on a server costing somewhere between $10 and $50 a month, plus a managed database in a similar range if you want one, plus the services it touches: Twilio charges per text message (check the current pricing page), a transactional email service like Postmark or Resend is often free or a few dollars at low volume, and a hosting platform like Vercel or Cloudflare has a free tier that many small tools never exceed.
The tools the developer uses to build it are paid for by the developer, in subscriptions or usage that run from tens to a few hundred dollars a month per engineer. The cost that does not go away is maintenance. Budget for a few hours a month of a competent person’s attention: dependencies need updating, a connected service changes its behavior, and your business changes its rules. Software that nobody looks at rots slowly.
The mistakes we see most
Buying the multiplier. A vendor says agents make them ten times faster and promises ten times the scope. Ask for a small fixed-price first piece and judge by what arrives.
No review step. The agent’s output goes straight to production because “it passed.” This works until the day it does not, and that day usually involves money or customer data.
Letting the vendor hold the keys. The code lives in the vendor’s accounts, the hosting is under their name, and the agent’s notes are their “proprietary process.” Then the relationship ends and you have a subscription to your own software.
When to bring in help
If your need is small and generic, you may not need custom software at all. A form builder or an off-the-shelf tool assembled with Zapier or n8n will do a great deal, and we discuss that trade in Build vs Buy AI Tools for Your Business, the Decision Rules. Some owners now use agentic coding tools directly for small utilities, and for a throwaway script that is fine.
The moment the software touches money, customer data, or a process the business depends on daily, you want a senior engineer directing the agents and reviewing the output. Someone has to know what the code must do, catch the confident mistakes, and be accountable for the result.
Levelbrook builds custom web apps, automations, and AI systems for businesses this way: agentic coding for speed, senior-engineer review for correctness, everything delivered with tests and notes into accounts you own, at a fixed price from a written scope. If you have a process that a spreadsheet stopped being able to hold, the form below is how a conversation starts.