One engagement at a time

You have everything you need to ship. Except the setup that makes it work. We build the engineering setup you're missing. One week.

A custom engineering harness — skills, memory, patterns, and agent workflows built for how you work. One senior engineer. Starting at $2,000.

See what's in the box

25 years of engineering. Building with AI every day, on real work.

One to two weeks Audit, build, embed, hand off.
$2k / $6k / $10k Fixed price. Not hourly. No change orders.
A senior engineer 25 years shipping. Building with AI every day.
01. The engagement

One week to build it. Two to make it stick.

Week one: we build your harness. Week two (Build + Embed tier): you use it on real work while we're still here to tune it.

  1. 01 · Day 1

    Audit

    A ninety-minute call and a look at your current .claude/ (if there is one), your stack, your workflow, and where you're losing hours. You leave the day with a written one-pager: what's broken, what's missing, what we're installing.

    • Interview: stack, domain, friction points, what you've already tried
    • Review of existing .claude/ directory, if any
    • Written plan of what goes in, scoped to the week
  2. 02 · Day 2

    Core install

    The foundation that ships with every harness. Skills library, memory system, global settings, baseline project CLAUDE.md. These are the pieces that don't change between clients — because they're load-bearing.

    • Skills: brainstorming, writing plans, executing plans, TDD, systematic debugging, verification before completion, commit discipline, wrap-session
    • Memory: directory, index, typed entry templates, SessionStart auto-load
    • Global settings: keybindings, status line, permissions, default model
    • Project CLAUDE.md boilerplate tuned to your standards
  3. 03 · Day 3

    Custom tuning

    The parts that are actually yours. Project-specific skills for your stack, your tool integrations wired in, executor/evaluator pattern connected to your code review workflow, pre- and post-commit hooks.

    • Language/framework skills tuned to your stack
    • Tool servers wired (Linear, Notion, Slack, Gmail, Playwright, etc.)
    • Executor/evaluator subagent pattern
    • Hooks: pre-commit verification, post-commit work-log append, wrap trigger
  4. 04 · Day 4

    Agents & second brain

    The parts that run on their own while you're not watching. Scheduled agents for daily / weekly / monthly reviews, automated work-log capture, maintenance crons.

    • Work-log capture into a second brain you own
    • Cron agents: daily check-in, weekly review, monthly strategic review
    • Maintenance: dependency audit, security audit, stale-branch cleanup
  5. 05 · Day 5

    Pair session & handoff

    Real work together on your code. Brainstorm → plan → execute → verify → commit → wrap, run against a feature in your repo. You watch the harness do its job.

    • Live pair session on a real feature
    • Walkthrough README with architecture diagram
    • Loom recording for your team
    • 14 days of async follow-up support
  6. 06 · Days 6–7 Build + Embed

    Solo flight

    You use the harness on your own real work. We're available async for questions and quick fixes. This is where the friction surfaces, and that's the point.

  7. 07 · Days 8–9 Build + Embed

    Refine

    Mid-week check-in call. Review what's working, what's friction, what needs tuning. Then a refinement day: adjust skills, hooks, memory based on what actually happened in practice.

  8. 08 · Day 10 Build + Embed

    Final pair session

    You run the full loop independently — brainstorm, plan, execute, verify, commit, wrap — while we observe and tune. You leave with a harness that's survived contact with reality.

02. What's installed

Six pieces. None of them magic.

Everything that goes into your harness, named and explained. The skill is knowing which pieces earn their place, and why.

Skills

Workflow rituals, encoded as executable prompts. Brainstorming, writing plans, executing plans, TDD, systematic debugging, verification before completion, commit discipline, finishing a branch, code review. Some come standard. Some get tuned to your stack.

Memory

Persistent state that survives across sessions. An index of what matters, typed entries for user preferences, feedback, project context, and external references, auto-loaded at the top of every session. The reason yesterday's decisions still apply today.

Hooks & config

Event-driven automation: pre-commit verification, post-commit work-log append, session-start memory load, session-end wrap trigger. Plus global config: keybindings, permissions, default model. The rituals that run without being asked.

Multi-agent patterns

Executor/evaluator via subagent-driven development. A code-reviewer subagent that runs on task completion. Exploration and planning subagents for deep work. The delegation layer that lets you keep judgment while the AI does the tedious parts.

Tool integrations

Wired servers for the tools you actually use: Linear, Notion, Slack, Gmail, Calendar, GitHub, Playwright, databases. The connective tissue between your harness and the rest of your stack.

Scheduled agents

Cron jobs that run while you're not watching: daily check-in, weekly review, monthly strategic review, dependency and security audit. The harness working on your behalf between sessions.

03. Pricing

Three ways in. Pick the depth.

All fixed-price. 50% upfront, 50% at handoff. No hourly billing, no surprises.

Audit

You want the roadmap. You'll do the work yourself.

A written report of what's broken, what's missing, and what to build, in priority order.

$2,000


  • 90-minute deep-dive call
  • Review of your current setup
  • Written report with priorities
  • 2-day turnaround
  • Credit toward Build if you proceed within 30 days

Build + Embed

You want the harness to actually stick. We use it together until it does.

Built in week one. Refined under real conditions in week two.

$10,000


  • Everything in Build
  • Week 2: you use it on real work, we're available async
  • Mid-week check-in + refinement day
  • Final pair session: you run the loop, we observe
  • Tuning based on real friction, not assumptions
  • 2 weeks delivery
  • 30 days of async support
04. Questions

Three things people ask.

What's actually in a 'harness'?

Everything listed two sections up: skills, memory, hooks, multi-agent patterns, tool integrations, scheduled agents, configured in your .claude/ directory and tuned to your stack. It's not a framework we license to you. It's a set of files we install, explain, and leave in your repo. You own them, edit them, throw away what doesn't fit.

What if my setup is already good?

Then we'll tell you on the intro call and turn you away. Honestly. Our moat is judgment about what earns its place, not booking a week we didn't deserve. If you send us your current .claude/ before the call, we'll audit it first and refuse the week if it's already solid. There are worse outcomes than walking away with a free audit.

Does this work if I use Cursor, Copilot, or something else?

The patterns port: executor/evaluator, memory discipline, work-log capture, scheduled reviews. Most of the tooling is Claude Code specific. If you're locked into another harness, tell us on the intro call; we'll either adapt what we can or be honest that this isn't the right offer for you. We'd rather send you away with a recommendation than sell you something that doesn't fit.

Ready to install?

Let's audit your setup this week.

30-minute call. Bring your existing .claude/ if you have one. We'll look at it together and tell you what a week with us would actually add.

[email protected]

Based in Amsterdam · Working worldwide