Which one fits which situation?
Each option is selling a different thing, and the price gap follows that. An agency sells a process and a set of people your procurement team can point at. A freelancer sells their own hours and their own judgement. A no-code builder sells speed inside the limits its tooling allows. An agentic senior developer sells what a senior engineer always sold, with the drafting done faster and the checking done the same careful way.
So the choice follows what the job actually needs: a process and paperwork a larger organisation can sign, one pair of hands answering quickly, the fastest route to something working without code, or one person accountable from the plan to the store listing and the month after launch.
If your real question is whether to hire anyone at all versus building it in a builder, that comparison has its own page: app builder or developer. This one is about who to hire once you have decided to hire.
| The situation | What usually fits | Why |
|---|---|---|
| A programme with several teams, audits and reporting | Agency | The paperwork is part of the product, and someone has to own it |
| A known fix inside a system somebody else built | Freelancer, or a takeover | Small surface, one skill set, no team ramp-up to pay for |
| An internal workflow four people use | No-code builder | Quicker and cheaper than any hire when the standard patterns already fit |
| A product with logins, payments and a store listing | Agentic senior developer | One person accountable end to end, at one fixed price |
| A first version to find out whether anyone pays | Me or a builder, depending on the idea | Learning beats architecture until someone opens a wallet |
The four options side by side
Fair to all four, because none of them is a trick. An agency that runs well is worth what it charges on the right job, and a good freelancer is the best value in this market on a narrow one. What the columns describe is where the risk sits and who carries it, not a ranking.
| The question | Traditional agency | Solo freelancer | No-code builder | Agentic senior developer |
|---|---|---|---|---|
| Cost to start | Highest: an account layer sits on top of the hours | Lower on the same scope, because the layer is one person | Lowest in the first months, then subscriptions and add-ons | One fixed price agreed in writing, from $2,999 for an app |
| Speed to a first clickable version | Slowest: discovery, scoping and ramp-up come first | Fast when the scope is small and they are free now | Fastest for the shapes the tool knows | Fast first draft, then the checking takes the time it always took |
| Who writes the plan | A manager and an architect, sometimes billed separately | The person doing the work | You, inside the tool's assumptions | Me, in writing, before any agent runs |
| Who checks the code | Another engineer on the same team | Nobody, unless you hire one | The platform, for the parts it allows | Me, line by line, with tests on the flows that cost money |
| Who owns the code and the accounts | Depends on the contract: work-for-hire is not automatic | You, if the contract says so, so ask before signing | The platform, until you can export and often after | You, from the first commit, in your repository and your store accounts |
| What happens when someone leaves | A handover inside the company; the name stays on the door | The knowledge leaves with the person | The subscription carries on and nobody knows why it was built that way | Written plan and handover notes; the monthly plan is optional, not a lock-in |
| Best for | Multi-team programmes, audits, long maintenance contracts | A defined piece of work in an existing system | Simple internal tools and quick landing pages | A whole small product: plan, build, store submission, support after |
| Worst for | A small fixed job where you would pay for the overhead | Anything needing several skills at once or cover while someone is ill | Custom logic, real data rules, owning your own product | A programme that needs five or more engineers on it |
How much faster is agentic development really?
Faster on some work, and the published evidence is honest about how much and how little. In a controlled experiment run by GitHub and Microsoft Research, developers with a coding assistant completed a self-contained task 55.8% faster than the control group. In METR's 2025 study of experienced open-source developers working on mature repositories they already knew well, being allowed to use AI tools made tasks take 19% longer, while the same developers finished believing they had been about 20% faster. Both of those are real, and they are the two ends of the range rather than a average of it.
The difference is what the task was. The fast result came from a small, well-specified job that the developers had not seen before. The slow one came from experts inside a codebase they already carried in their heads, where describing the change to a tool cost more than writing it. My work sits between those two, nearer the fast end when the job is new screens, forms, list views, report queries, tests and plumbing, and nearer the slow end when it is one careful change to something only I understand.
What I take from it is the same line I put on the agentic software development page: the drafting got much cheaper and the parts that were never about typing did not. The first call, the plan, the data rules, the privacy answers Apple and Google ask for, and the decision about what not to build still take what they take.
Where the speed is real for you is in the first clickable version and in every revision after it. A change you ask for on Tuesday is on your phone on Wednesday, and that is the part a fixed price absorbs and an hourly invoice does not.
Where do agents save time and where do they not?
The split is the same one I use on every build, and it is not a rule about which tool is cleverest. It is one question: how much of this job is typing, and how much of it is knowing your business.
- Where the risk of being wrong is high, an agent drafts and I write or rewrite the part myself. That is the same conclusion as the checklist on the AI-assisted coding guide.
- The demo is not the difficult part any more, which is why so much work now arrives as a cleanup: see the vibe coding cleanup guide for what that costs.
| Saves real hours | Saves nothing |
|---|---|
| Screens, forms, filters and list views | Deciding what the product should do |
| Test scaffolding and the boring coverage | A data model you only get to design once |
| Migrations and repetitive plumbing with a clear pattern | Permissions, payments and the failure paths |
| First drafts of copy variants and reports | Store submissions and the privacy forms |
| Reading an unfamiliar library's API so I do not have to | Cleaning up data someone else typed in by hand |
| Revisions you ask for week after week | Anything that takes more care to explain than to write |
What does agentic software development cost?
There is no premium for the agentic label and no discount for it, because you are paying for the thing you asked for. My published starting points are on Services: an app from $2,999, a web app or dashboard from $799, an automation from $499, a landing page from $299. Small jobs start at $49. Support after launch is from $149 a month.
Why an agency quote for the same scope comes in higher, in plain terms: you are paying for a name, a manager, a designer, a QA person and the paperwork that comes with them, and on some jobs that is exactly what you need. On a small product the account layer is a large share of the bill, so the same scope costs less with one engineer and more the more seats sit around it. I am not going to quote you a market average for agency rates, because I do not have a source I would put my name on.
What to hold every option to, including me: one fixed price, agreed in writing before the first line exists, with the date and the handover written in the same document.
How do you compare quotes from different kinds of supplier?
Ask the same six questions in the same words to all of them, and write the answers down. They tell you more than the price line does, and what an app costs walks through the arithmetic behind each number.
- Is the price fixed or hourly, and what is the thing that makes it change?
- Who writes the plan, and is it inside the price or billed as a separate phase?
- Who reads and tests the code before it ships, and what stops it if it is wrong?
- Who owns the repository, the store accounts, the server and the keys afterwards?
- What happens in month three when something breaks and the person who built it is busy?
- What is the handover, exactly, in writing?
When should you not hire me?
When the work needs several teams at once, formal audits, or a supplier your procurement department can hold to a contract, an agency is the better answer. If the plan needs five or more engineers, a compliance function, or 24/7 cover with a phone number and an escalation path, hire the firm that provides those, because I do not and no tool changes that.
When the job is a simple internal workflow that a handful of people use and nothing unusual is in the rules, a no-code builder is faster and cheaper than I am, and paying an engineer to rebuild what a template already does is a bad hire.
When the work is one narrow job inside a system I have never seen, the freelancer who already knows that codebase will beat me on both price and time.
And when what is actually missing is agreement inside your own company about what to build, software will not settle it. I build what the plan says, and I will not charge you for pretending to be a strategy department.
What to remember
- Choose by what the job needs from the person, not by the size of the shop.
- An agency's price contains the account layer, a solo price contains only the hours, a builder's price contains its limits.
- Agents made typing cheaper and left the decisions at their old price.
- The AI speed research is genuinely mixed: 55.8% faster on a self-contained task, 19% slower for experts in code they already knew.
- Own the repository and the accounts from the first commit, whoever builds it.
- Ask the same six questions of every quote; the differences show up in the answers, not the totals.
Sources
Primary documentation, for anyone who wants to check the details.