AI is changing how much one technical person can build

I've spent around 15 years building websites and digital systems. AI hasn't suddenly made that experience unnecessary. It's given me far more capacity to use it. And I think that's going to change what small technical teams can build.

Something quite strange has happened to my working day. I can now move between building an application, debugging some code, working through a database problem, designing an interface, connecting an API, researching something unfamiliar and testing an idea without necessarily handing each part to a different specialist. AI doesn't mean I suddenly know everything about all of those things.

I don't. What it gives me is access to a huge amount of execution capacity around the knowledge and experience I already have. And after around 15 years working in web development and digital, I think that's one of the most significant changes AI has made to how I work.

One technical person can now attempt things that would previously have required considerably more time, more specialists or a bigger team. That's not the same as saying one person can do everything. But the boundary has moved.

A lot.

Software used to have an expensive translation layer

Imagine you have an idea for a product. The idea itself might be reasonably simple. But turning it into something people can actually use requires a long list of things.

You need to work out the user journey. Design the interface. Build the front end.

Build the back end. Create the database. Handle authentication.

Connect services. Integrate payments. Write emails.

Deal with errors. Test everything. Deploy it.

Monitor it. Fix what breaks. Depending on the project, you might have needed several different people involved.

Or one person who could do several of those things, but a lot of time. AI compresses parts of that process. Not because the work disappears.

Because you can delegate increasing amounts of the execution.

I can stay at the level of the problem for longer

This is perhaps the biggest change for me. Previously, I might know exactly what I wanted a system to do and then spend a substantial amount of time implementing each part. Now I can spend more of that time thinking about:

What should happen here? What does the user need? Where should this information come from?

What happens next? What could go wrong? What should this connect to?

What should the AI be allowed to access? Where does a person need to intervene? Then AI can help translate those decisions into implementation.

That's a very different relationship with the technology.

The distance between an idea and a working version has collapsed

This is the bit I still find extraordinary. You can have an idea in the morning and have something genuinely functioning surprisingly quickly. Not a production-ready business.

Not necessarily something you'd give to thousands of customers. But enough to answer an important question: Does this idea actually work?

That changes experimentation. Ideas that previously would have remained on a list because they weren't worth several weeks of development can now be tested. Most will still be bad ideas.

That's fine. The difference is that finding out can be much cheaper.

I've seen this in the products I've been building

This isn't theoretical for me. I've been building products where AI is part of either the product itself or the way the product gets built. ClearaScan is a consumer application designed around a very specific problem: helping somebody check products against the ingredients they personally need to avoid.

That involves much more than putting an AI chat box on a page. There's the application. User profiles.

Product information. Scanning. Data.

Mobile platforms. Payments. The logic around what the user needs to avoid.

And the experience of making the whole thing usable when somebody is standing in front of a product and wants an answer. Fightingback tackles a completely different problem. It helps people turn a situation they're dealing with into a structured, tailored letter they can actually use.

Again, the AI output is one piece. The product around it is what makes that capability useful. And then there are platforms like MamaMind, where AI isn't necessarily the product at all.

It's a membership platform with courses, community and payments. But AI changes how quickly I can build, change and maintain the software underneath it. Those are three very different products.

That's part of the point. AI isn't simply giving me one new technical skill. It's increasing the range and speed of what I can execute around skills I already had.

The person still needs to know what they're looking at

This is the bit that gets lost in some of the excitement around AI coding. AI can produce code I wouldn't want to write manually. Brilliant.

But when it changes something, I still need to understand: what it changed, why,

what else it might affect, whether it fits the rest of the system, whether the approach is sensible,

and whether we're solving the right problem. You don't need to type every line yourself to be responsible for what the software does.

Experience becomes leverage

This is why I don't think the story is simply: AI makes technical expertise less important. In some situations, AI absolutely lowers the amount of expertise required to get started.

That's a very good thing. People who couldn't previously build software can now make functioning tools. But there's another effect happening at the same time.

If you already understand: websites, databases,

APIs, hosting, authentication,

ecommerce, analytics, integrations,

user journeys, business processes, and how digital systems fit together,

AI gives you a much larger execution engine around that knowledge. You can ask better questions because you know which questions matter. You can recognise a strange answer.

You can spot when the proposed solution is fixing the wrong layer. You know that a feature which looks simple may have consequences somewhere else. The AI hasn't replaced the experience.

It's multiplying what you can do with it.

This isn't unique to developers

I think this pattern will appear in lots of professions. An experienced marketer with AI can produce and test much more. An experienced researcher can investigate more.

An experienced lawyer may be able to work through far larger volumes of material. An experienced analyst can explore more possibilities. An experienced operator can manage more processes.

The interesting combination isn't: AI instead of expertise. It's:

AI multiplied by expertise. Someone who understands the domain can use the additional capacity differently from someone who doesn't yet know which parts require care.

Small teams suddenly have much more reach

This is where I think things become particularly interesting for businesses. Historically, company size affected capability quite directly. A larger business could have:

developers, designers, analysts,

operations teams, researchers, assistants,

marketing teams, and specialists. A smaller business couldn't justify all of those roles.

AI doesn't erase that difference. But it can narrow parts of it. A technically capable person in a small company can now access assistance across coding, research, analysis, documentation, testing and implementation without employing a specialist for every individual task.

That changes what a small team can realistically attempt.

It doesn't mean you never need specialists

Quite the opposite. There are points where I want someone who knows much more about a particular subject than I do. Security.

Complex legal issues. Specialist infrastructure. Design problems where the quality really matters.

Unusual performance issues. High-risk decisions. AI doesn't make expertise disappear.

It can actually make it easier to recognise where specialist expertise is worth paying for. If AI handles more of the ordinary implementation, you can bring a specialist in for the part where their knowledge genuinely matters.

The shape of a technical team could change

Traditionally, a project might have been divided by output. Designer. Front-end developer.

Back-end developer. QA. Project manager.

Perhaps AI changes some of that structure. One person may increasingly be able to move across several layers, using specialised AI systems to help execute the work. That person becomes less like somebody performing every task and more like somebody directing a technical system that performs many of them.

I think that's an important distinction. The human isn't necessarily doing less thinking. They're doing less of the mechanical implementation.

Managing AI is becoming a technical skill

This is more than knowing how to write a clever prompt. When I use AI to build something, I need to decide: what context it needs,

how much of the problem to give it, when to let it continue, when to stop it,

what needs testing, when the approach is getting messy, when to start again,

and when I don't trust what it has done. That's management. Not people management exactly.

But there are similarities. You need to communicate the outcome. Give enough context.

Review the work. Correct misunderstandings. And know when something that looks finished isn't actually finished.

More output can create a new problem

If AI allows one person to produce five times as much technical work, that doesn't automatically mean they should. Now you potentially have: more code,

more features, more experiments, more applications,

more integrations, and more things to maintain. The limiting factor may stop being creation.

It becomes attention. Which things deserve to keep existing? Which experiments become products?

Which code is worth maintaining? Which feature actually improves the product? Which idea should be killed?

AI makes adding things extraordinarily easy. That makes saying no more valuable.

Maintenance doesn't disappear

This is worth emphasising because the first build is the exciting bit. Software doesn't end when it works. Services change.

Libraries update. APIs change. Operating systems change.

Customers find unusual ways to use things. Security issues appear. Business requirements change.

Something you built six months ago suddenly needs attention. If AI lets one person create much more software, that person can also end up owning much more software. Fortunately, AI helps with maintenance too.

But the total surface area still matters.

One person can build more. One person can also create more mess.

There is an uncomfortable version of this story. A technically capable person with AI can build an extraordinary amount. A technically inexperienced person with AI can also build an extraordinary amount.

Sometimes without understanding what they've built. That can mean: security problems,

fragile systems, duplicated functionality, poorly understood dependencies,

personal data being handled incorrectly, and applications nobody knows how to maintain. The speed is real.

So is the need for judgement.

This could change agencies too

I think this is particularly interesting from where I sit. Digital agencies have traditionally sold a lot of execution. Design hours.

Development hours. Content hours. Technical hours.

AI reduces the amount of human time required for some of that execution. That creates an uncomfortable question if your value proposition is mainly: We have people who can do the work.

But it creates a much more interesting opportunity if your value is: We know what should be built and how the pieces should work together. Clients don't ultimately want 40 hours of development.

They want the thing the 40 hours were supposed to produce. If the same outcome can be produced in ten hours with AI assisting the work, charging for inefficiency isn't a sustainable business model.

The value moves towards judgement

This is where I think a lot of technical businesses are heading. The valuable questions become: What should we build?

Which problem is actually worth solving? Which technology is appropriate? What shouldn't be automated?

Where should the data live? How should the systems connect? What should the AI be allowed to do?

What needs human approval? How do we know whether this is actually working? Those questions aren't disappearing.

They're becoming a larger proportion of the job.

This is why my pre-AI experience matters more to me now, not less

Before spending around 15 years in web and digital, I worked in roles involving sales, infrastructure and business processes. At the time, those looked like different parts of a career. Now they fit together rather neatly.

Because building useful AI systems isn't only about understanding AI. It's about understanding: the customer,

the commercial problem, the process, the technology,

the infrastructure, and how all of those things interact. AI is the new layer.

The systems underneath it aren't new.

There is another side to this: tiny companies can attempt bigger things

This is the part I find most exciting. A founder with the right experience and AI assistance can now test products that previously might have required funding just to build the first useful version. A small agency can create internal software instead of buying another subscription.

A company can automate an awkward process that would never have justified a traditional software project. A technically capable employee can build a tool for their team without waiting six months for an engineering roadmap. The economics have changed.

That doesn't guarantee any of those things will be good. But it means far more of them can exist.

The one-person technical team isn't literally one person

This is probably worth clarifying. I'm not predicting companies will fire every technical employee and give one person a laptop full of AI agents. Large, complicated systems still require teams.

Different perspectives matter. Review matters. Specialist knowledge matters.

And there are limits to how much one person can understand and be responsible for. The change is more subtle. The amount of technical capability represented by one person is increasing.

That changes hiring. Agencies. Startups.

Internal teams. Product development. And what counts as a viable idea.

We may need to stop measuring teams by headcount

A five-person technical team in 2026 isn't necessarily comparable with a five-person technical team from a few years ago. What matters increasingly is: what they can build,

how quickly they can test, how well they use AI, how much domain expertise they have,

and how effectively they can direct automated systems. The number of people tells you less about the amount of capability available.

There's a flip side for businesses buying technical work

Businesses may also need to rethink how they evaluate suppliers. If a project used to require 100 development hours and can now be completed safely in 30, the interesting question isn't: Where did the other 70 hours go?

It's: Did we get the right outcome? That pushes technical services towards value, expertise and results rather than simply selling time.

I think that's healthy.

So how much can one person build now?

More than they could a year ago. Much more than they could several years ago. And probably considerably less than they'll be able to build a few years from now.

But the number of lines of code isn't the part I find interesting. It's the widening gap between an idea and the resources required to test it. AI is shrinking that gap.

That means more people can build. Small teams can attempt bigger things. Experienced technical people can operate across a much wider area.

And businesses can justify solving problems that were previously too small to justify custom development. But there's an important condition attached. More capacity only becomes more valuable if you know where to point it.

That's why I don't think AI has made my previous 15 years in technology less relevant. It has made those years considerably more useful.

Where to go next

• What happens to software development when AI writes most of the code? Why cheaper implementation moves value towards architecture, judgement, testing and knowing what is worth building.
• Why your AI demo worked and your AI implementation didn't Building quickly and building something a business can actually depend on are still very different things.
• AI has changed the build-versus-buy calculation When custom software becomes cheaper to create, does another SaaS subscription still make sense?
• Don't start with AI. Start with the work. More technical capacity isn't useful unless you point it at the right problem.

Related: What happens to software development when AI writes most of the code?.