Stuff we've built

Build

Coding was never the hard part.

The hard part is working out what to build, in what order, and making sure what gets built is what you needed. Build is the platform we run our build engagements on. It takes a project from an idea, or from an existing system, to a production-ready app in weeks, not months.

If we build something for you, this is what it looks like from the inside.

A Build task: the deliverable document on the left, and the discussion that shaped it on the right.

Most AI tools bet on typing

They assume writing code was the bottleneck, so they write it faster and call it done. A prompt becomes a repo, the architecture is whatever the model felt like, there are no requirements to check against, and the bugs turn up in production.

We bet on the decisions

Build produces a real document at every step: a hypothesis you can defend, a data model you can build against, tickets a developer or a coding agent can carry out, and a test record that says what got built and what didn't. Each one feeds the next as structured input, not paragraphs of prose hoping the next step gets the gist.

How a project runs

Every project follows the same backbone. You don't need to know what comes next: the platform does, and it won't let anyone skip ahead.

Understand

If something already exists, agents read it first: the code, the data, and the decisions behind them. Then we stress-test the idea and shape it into something you can defend: who it's for, what it must do first, and what can wait.

Specify

We settle the stack, surface the risks, and specify the data model, the interfaces between systems, and the acceptance criteria. Then the design: a visual direction, reusable components, and a product you can click through.

Plan the work

The specification becomes epics, tickets, and tasks. Before the plan is published, it's checked for contradictions, so the tickets agree with each other and with the spec.

Build

Coding agents connect to the project and build against the spec instead of guessing, alongside the people working the tickets that need a person. Progress, check-ins, and questions flow back, so the project record stays current.

Test and accept

Automated delivery, code-quality, and security scans, then your own findings, sorted by an agent and reviewed by a person. Delivery is accepted when both your sponsor and our engagement manager sign it off.

Keep going

After delivery, a retro on how the work went, separate from whether the product works, and a standing roadmap for what comes next.

Built by agents, people, or both

Requirements written in Build are written to be built by anyone: coding agents, a human team, or a blend of the two. Each ticket carries the data model, the acceptance criteria, and the edge cases it needs, so whoever picks it up isn't guessing.

Your tickets, where you work

Run the tickets inside Build, or export them to the tool your team already uses. Either way, the specification stays in one place, and the build is checked against it.

Agents do the volume; people hold the gates

Inside each phase, a small team of specialist agents takes turns: one researches, one drafts, and one works it through with you in the discussion. Agents draft; people decide. Each phase stays locked until a person closes the one before it, and a phase can't close until its documents have been checked against each other.

Agents

  • Research, comparable products, and market scans
  • Requirements capture and first-draft architecture
  • Tickets and acceptance criteria
  • Test runs, and code-quality and security scans
  • Pulling together feedback from everyone on the project

People

  • The idea itself, and the IP that comes from it
  • The trade-offs the agents flag
  • Closing each phase before the next one opens
  • Reviewing test findings, and overruling the agent that sorted them
  • Accepting delivery
Build's discussion panel: each question a specialist raised, and how it was resolved.

Start from scratch, or from what you've got

Most projects don't start from a blank page. When something already exists, Build reads it first: the codebase, the data, and the decisions, or, for a website, just the live site's address. Phases that don't apply are skipped automatically.

  • A new product or platform, from an idea
  • A website, with or without an existing one
  • A full rewrite of an existing system
  • A new front end on your existing back end
  • A new back end behind your existing front end
  • A new feature on a system that already ships
  • The same product and design, rebuilt on our stack
  • A code analysis on its own, when the analysis is the job

Built to be trusted with an idea

A product idea, its data model, and its design are worth protecting. Each project's content is encrypted under its own key, and access is granted project by project. Erasing a project means destroying its key, then removing the content.

We design Build, and the platform under it, for SOC 2 and GDPR readiness. That's the same standard we hold the systems we build for clients to.

In closed beta

We're running Build with a small number of clients while we tighten the process. If this sounds like the way you'd want something built, ask for an invite: a short conversation, then we either find a fit or we don't.

Often goes with

A build engagement is Product Strategy and Solutions Architecture, done in the open.

Ready for a conversation?

No sales pitch. No obligation. Just a chat about what you're building and where the opportunities might be.