One of the arguments for hiring an agency died quietly over the last year.
That argument was capacity.
Until now, the math was simple. A freelancer is one person. An agency can put two or three developers on your project, and when the deadline is real and the outcome is yours to answer for, a bigger team feels safer.
Then agentic coding broke that.
I build Laravel apps with Claude Code in the loop, and the scope I can carry alone today is the scope I would have turned down a year ago.
Now the part that should worry you more than it excites you…
AI multiplies mediocre developers just as eagerly as senior ones. More code, faster, with less thought behind it. So AI didn't pick a side in the freelancer vs agency debate. It erased capacity as the differentiator and raised the stakes on the individual.
What you evaluate now is not which business model to buy, but which one person is actually building your project.
Because failure won't look like failure.
A mediocre developer with AI hits your deadline and ships a "working" project. The technical debt surfaces later, after handover, when it's your team stuck maintaining it.
I'll show you the new math, where an agency still genuinely wins, and how to vet the one person who matters, whichever door they work behind.
The capacity math just flipped
For most of my 10 years in web development, capacity really was headcount. Code got written at the speed of human typing and human thinking, one keyboard at a time. If your project needed forty features in four months, you needed more keyboards.
Agentic coding ended that. Claude Code takes a task, plans it, writes the migration, the model, the tests, runs them, reads the failures, and fixes bugs, while I review and steer. Laravel Boost feeds it the exact documentation for the exact package versions in my project, and PHPStan catches anything that doesn't earn its place.
What AI cannot do is decide which shortcut will hurt in six months, or whether the client's "simple rule" is actually three business rules wearing a trench coat.
So, capacity stopped being a headcount number. It became a judgment number.
A team's output used to be limited by how fast it could type. Now it's limited by how well it can decide.
That eliminates the agency's headcount advantage. Five people don't just write more code, they create ten communication channels, since paths grow faster than headcount, Fred Brooks's old observation: meetings, handoffs, misremembered kickoff calls.
One developer directing AI agents creates none of that. And the raw code volume those five keyboards used to buy is now nearly free on both sides.
Context is the bottleneck now
There's a second effect, and it's the bigger one…
An AI agent is only as good as the context of the person directing it.
When I direct an agent, I'm holding everything from the discovery call: the client's real margin problem, the warehouse quirk they mentioned in passing, the feature they asked for versus the outcome they need. Every prompt carries that context, and the output shows it.
Run the same tool through an agency, and the person who heard your problem is the account manager, while the person directing the AI is a developer working from a ticket, often the third retelling of what you actually said.
Typing code used to be the expensive part, so that split made sense. Agentic coding inverts it. Typing code is cheap. Context is the whole product, and the agency's structure starves the person at the keyboard of exactly the thing that now decides quality.
But AI cuts both ways
If you stopped reading here, you'd conclude "hire a freelancer with AI tools." Not so simple.
AI is a multiplier. Hand it to a senior developer and you multiply judgment. Hand it to a mediocre one and you multiply the mediocrity: more controllers, more complex queries, more plausible-looking abstractions, generated faster than any human could write them and with less thought than any human would have given them.
AI didn't raise the floor of development work. It raised the slope. Good developers got much better. Bad developers got much faster.
And the failure mode got nastier. Bad outsourcing used to fail slowly and visibly. Now it fails fast and invisibly. The demo arrives early, the features all exist, and the codebase underneath is generated sprawl nobody fully read, with tests that assert nothing. You find out when change requests start taking far longer than the original build.
Which is why the business model tells you nothing. The developer who tanks your project might be a solo freelancer, or the third-best developer at a respectable agency, handed your account because the best one is on a bigger client.
Where an agency still genuinely wins
I'm a freelancer telling you the capacity argument expired, so let me argue the other side properly. There are projects where I'd tell you to hire an agency.
Genuinely parallel disciplines. You're launching a product that needs brand design, copywriting, development, and a paid marketing campaign landing in the same month. AI made me a more productive developer. It did not make me a brand designer or a media buyer.
Decision density beyond one head. A large, long-running product can generate more architectural and product decisions per day than one person can make well, no matter how much typing the AI absorbs. When the bottleneck is judgment and you genuinely need more judges, you need more senior people.
Procurement and compliance gates. Some organizations contractually cannot hire a sole operator. They require vendor insurance, security audits, staffing continuity guarantees, a legal entity big enough to sue. If your procurement process demands that, the comparison was decided before it started, and that's totally fine.
You refuse to manage the relationship. A good agency sells you the absence of involvement. If you truly want to hand over a brief and see results without ever talking to a developer, an agency is built for that. Just understand what I wrote two sections ago about context starvation. You're paying extra for a structure that also dilutes quality. Know that you're choosing it.
Every one of those cases still ends at the same checkpoint. Hire the agency for the parallel disciplines, the decision density, the compliance paperwork. Then vet the specific developer they put on your code with exactly the rigor you'd apply to a freelancer. The agency's brand answers none of the questions that follow.
How to vet the person who will actually touch your code
Five checks, and they work identically whether the person sits behind a freelancer's website or an agency's.
1. Get the developer's name, then get them on a call
Not the account manager. Not the technical director who "oversees all projects." Not even a tech lead who sets the standards. The person whose hands will be in your codebase daily. A freelancer is this person by definition.
An agency that won't put the actual developer in front of you before you sign is telling you something. Listen to it, and walk.
2. Read their work in public
Open-source packages, technical posts, conference talks. I built and maintain Bedrock, a Statamic starter kit, partly because shipped public work is the only credential that can't be inflated.
Public code that strangers use, with issues answered and updates shipped over the years, is the signal. Its absence is also a signal.
3. Ask how they use AI
Two answers should end the conversation:
"We don't use AI, it produces garbage." Translation: they haven't seriously tried agentic coding in a year when it remade the economics of their own industry. That's not caution, that's a curiosity problem.
"AI writes basically everything now." Translation: nobody is reading the code. You'll find out what that means in six months, not in the demo.
The answer you want describes a leash: AI does the busywork, the human owns architecture, review, and understanding.
In my case, the leash is Pest tests the agent must keep green and PHPStan, a static analysis tool that catches the slop. The specific tools matter less than whether a leash exists at all.
The best filter I know:
Ask one question: "What do you not let the AI do?" Developers with judgment answer instantly, because they hit those boundaries every day. Developers without it have never thought about the question.
4. Ask what a handover includes before the project starts
The right answer covers tests, documentation, and a working assumption that your team, or your next developer, can own the code without the author in the loop. Every project I ship is built to that standard, not out of generosity.
Code only the author can maintain isn't an asset. It's a hostage situation with invoices.
5. Ask about a decision that went wrong
Have them walk you through a past architecture choice, the trade-off behind it, and one they'd take back. You're not grading the technical content. You're checking whether trade-offs and mistakes are things they think about at all.
Judgment is the thing you're renting now.
Andrej Karpathy put it this way, when asked, “…what human skill becomes more valuable?”
You still have to be in charge of aesthetics, judgment, taste, and oversight.
Stop asking which door. Ask who's behind it.
"Freelancer or agency?" was always a proxy question. It stood in for the real one, "will the work get done well and on time?", back when headcount was a reasonable predictor of that.
It isn't anymore. The capacity argument expired, the coordination tax didn't, and AI turned the individual developer's judgment into the single variable your project's outcome hangs on, in both business models.
So get their name, read their work, and check their judgment before a single line of your code gets written.
More developers stopped being safer than one. The right one, with the right tools and the full context of your problem, is your safest bet. The wrong one is faster at being wrong than ever. Everything rides on telling them apart, and now you know how.