Darin

Our thesis

Coding is becoming free. Taste is the new bottleneck.

With Claude Code, Codex, and a wave of software factories, building software has never been easier, and it's only getting easier. As the cost of writing code falls toward zero, the hard part is no longer how to build. It's deciding what to build, and in what order. We call that taste.

Coding was never the bottleneck

The software development lifecycle is far bigger than typing code. Discovery, prioritization, design, specs, review, QA, release, feedback, and iteration. Writing the code was always a thin slice of the work.

For decades that slice was the constraint, so the entire industry optimized it: faster editors, better languages, more libraries. Now agents are dissolving it. When code is cheap, the value moves to the parts that were always hard for machines: judgment, priorities, and knowing which problem is worth solving.

The right way to understand this shift is the way we understand self-driving cars. Autonomy doesn't arrive all at once. It climbs in levels. Each one hands more of the doing to the machine, until the only thing left for a human to supply is intent: where do we want to go?

The autonomy ladder

Five levels of autonomy in the SDLC

Borrowed from the SAE's framework for self-driving cars, from driver assistance to full autonomy, and mapped onto how software gets built.

  1. Level 1

    Assisted coding

    Cruise control and lane-keeping. The human drives, the machine smooths the work.

    Autocomplete, tab completion, and in-editor assistance. The engineer is still doing every line, but the friction between thought and keystroke collapses.

    Unlocks: Massive individual productivity gains.

    • Cursor

      Took the market with AI-native editing and autocomplete.

    • GitHub Copilot

      Brought inline completion to the mainstream.

  2. Level 2

    Autonomous CLI agents

    Hands off the wheel on the highway. You supervise closely, ready to take over.

    Terminal-native agents take a task and execute multi-step changes on their own. Spec-driven development and TDD become the steering wheel. You describe intent and constraints, the agent writes and iterates.

    Unlocks: Whole tasks, not keystrokes, get delegated.

    • Claude Code

      Agentic coding from the terminal, end to end.

    • OpenAI Codex

      CLI agents that plan, edit, and run.

  3. Level 3

    Software factories

    Robotaxi in a mapped city. Assign a destination, get dropped off, review the ride.

    Coding agents become teammates on the board. Assign a ticket, get back a pull request. Work runs in cloud sandboxes; humans triage, steer, and review diffs instead of writing the code themselves.

    Unlocks: Kanban-style delivery: issues in, reviewed PRs out.

    • Factory.ai (Droids)

      "Software development is more than just coding." Droids across the SDLC.

    • Linear Agents

      Delegate an issue, get a diff from a cloud coding session.

    • Ramp

      Internal agent fleets inspecting and shipping work at scale.

  4. Level 4

    The closed feedback loop

    Where Darin lives

    Fully autonomous in its domain. The car decides the route from where you need to be.

    The system listens. It captures user feedback, product analytics, customer conversations, and bug reports, turns them into prioritized tickets, ships the fix, and closes the loop, measuring whether the change actually worked.

    Unlocks: Software that observes itself and improves without a prompt.

    • Darin

      The decision layer: signal in, prioritized specs out. This is our home base.

  5. Level 5

    The artificial general engineer

    Anywhere, any road, no map. Full autonomy across every engineering domain.

    Not just software. A general engineer that designs, simulates, and iterates across CAD, chip design, hardware, and robotics, running its own hill-climbing feedback loops against the physical world.

    Unlocks: Invention itself gets faster.

    • The north star we're building toward

Darin is the navigator, not the engine

Levels 1 through 3 automate the doing. The factories can write the code, open the PRs, and ship. But a factory pointed in the wrong direction just produces the wrong thing faster.

Darin automates the deciding. We read everything your customers and team are telling you across Slack, support, calls, and analytics, then hand back clear priorities and specs, with the reasoning behind every call. That's the taste layer the rest of the stack is missing.

Today that makes Darin the decision engine that feeds the software factories. Tomorrow, it's the closed feedback loop of Level 4: capturing signal, deciding what matters, dispatching the work, and measuring whether it landed, all without waiting to be asked.

And we're aiming at Level 5. It's the same dream Prometheus calls an artificial general engineer, applied first to the thing we know best: the full lifecycle of building product. A system that knows what's worth building, not just how to build it.

Help us build the taste layer

If code is free, the teams who win are the ones who decide best. Get early access to the product mind that remembers everything and tells you what to build next.

← Back to Darin