Build

Software built quickly, by one person and a fleet of agents.

Websites, web applications, prototypes and internal tools. You deal with me from the first call to the handover, and you see working software early.

What I build

Four kinds of work.

All of it runs in the browser, and all of it is built the same way: small steps, checked as I go.

Websites

Clear, fast sites for a company, a product or a practice.

Web applications

Software people log in to and use for their work.

Prototypes

Something real enough to test an idea with the people it is for.

Internal tools

The system your team needs and nobody has time to build.

How a project runs

From first call to handover.

  1. First call

    We talk about what you want built, who it is for and what it has to do. I tell you honestly whether I am the right person for it.

  2. Short scope

    I write down, in plain words, what I will build first, what comes later and what is out. We agree on it before I start.

  3. Working software early

    You get something that runs, on a link you can open yourself, early in the project. From then on you judge real software, not descriptions of it.

  4. Short cycles

    I build in small steps and show you each one. You steer as we go, and changing course stays cheap because the steps are small.

  5. Handover

    You get the code, the documentation and the tests, and I walk you through how it fits together. Then it is yours.

One person to deal with throughout. The person on the first call is the person who builds it and hands it over.

Why it is fast

One person directing a fleet of agents.

A fleet of AI agents writes most of the code. I decide what gets built, set the direction and check every result before it reaches you.

The speed comes from fewer handovers and no team to coordinate, not from cutting corners. Tests and review stay in, the same as I would expect from a good team.

The agents build

They do the typing, many tasks at once.

I check every result

Nothing reaches you that I have not read and run.

Nothing skipped

Tests are written and run, and every change is reviewed.

What you get at the end

Your software, fully yours.

You don't need me to keep it running. Another developer can pick it up where I left off.

  • Your code, in your own repository
  • Documentation on how it works and how to run it
  • Tests that show it does what we agreed
  • No lock-in
Where it fits

Small and clear works best.

A prototype to test an idea

Find out whether it works before you spend serious money on it.

A first version

Something real to put in front of your first users.

A tool your team needs

The internal system that would save time, if only someone built it.

If it needs a team of ten for two years, I'll say so.

Pricing

The price follows the scope.

A fixed price per agreed scope, after a short scoping call. A day rate for open-ended work.