Should I hire an agency, a freelancer, or an agentic developer?
I build apps, websites and automation for small businesses and founders, and I am one of the four options in this comparison, so I wrote it with my own column kept honest. Four ways to get software built, compared by wh
I build apps, websites and automation for small businesses and founders, and I am one of the four options in this comparison, so I wrote it with my own column kept honest.
Four ways to get software built, compared by what they sell you rather than by what they call themselves. The honest version, including the jobs where I am the wrong answer.
Short answer:
- An agency sells a process and people to point at. A freelancer sells their own hours. A no-code builder sells speed inside a tool's limits. An agentic developer sells what a senior engineer always sold, with faster drafting.
- The price gap is mostly the cost of the people who are not writing code, not a difference in quality.
- Agents made the typing cheaper. They did not make the decisions cheaper, and the decisions are most of what you pay for.
- The published research on AI coding speed genuinely disagrees with itself: one controlled task finished 55.8% faster with an assistant, while experienced developers working inside repositories they already knew took 19% longer.
- Ask the same six questions of every quote. Who owns the code and the accounts afterwards is the one most buyers forget to ask.
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.
Takeaways:
- 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.
Q: Is an AI-assisted developer cheaper than an agency?
A: On the same scope, usually yes, because there is no account layer sitting on top of the work. That is a difference in the shape of the business, not in quality. The gap closes when the process is what you are buying: several workstreams, audits, and cover while people are ill. My own prices do not change with how the code gets drafted, so an agentic build is not a premium and not a discount.
Q: Can I hire an agency and an agentic developer together?
A: Yes, and it is a common shape. The agency owns the platform and its process, and one person builds and ships a defined piece inside it. Fix two things in writing before starting: who signs off the merge into the shared branch, and who answers when something breaks outside office hours. Everything else follows from those.
Q: Do I still need a person if AI can write the code?
A: You need someone who owns the outcome, and that is what you have always been buying. A model can write a refund flow; it cannot decide what your business should do when a refund is wrong, whose fault it is when a payment fails twice, or whether this screen should exist at all. In all four options the accountable human is the product.
Q: Who is responsible if agentic development gets something wrong?
A: Me, and only me. It is one contract, one name and one fixed price, so there is nobody to hide behind when a screen misbehaves. The terms do not change because part of the work was drafted by an agent, and you do not have to take my word for any of it: the repository starts in your name, and the handover says which parts came from an agent and which I wrote.
Q: Does AI-written code hold up in production?
A: Only when someone reads it before it ships. Whatever the tooling, the failures arrive in the same handful of places, and none of them is a syntax problem: who is allowed to see this record, what happens when a charge fails twice, what the app shows when the network does not answer. That is a checklist rather than a model choice, and mine is written out on the AI-assisted coding guide.
Sources:
- METR: measuring the impact of early-2025 AI on experienced open-source developer productivity: https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
- GitHub research: quantifying GitHub Copilot's impact on developer productivity and happiness: https://github.blog/news-insights/research/research-quantifying-github-copilots-impact-on-developer-productivity-and-happiness/
Originally published at https://najam.dev/guides/agentic-developer-vs-agency/. If you want the short version of how I work: one engineer, one fixed price agreed in writing before anything starts, and the code and the accounts stay in your name. More at https://najam.dev
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.