B.O.S.S.
Build Out Solid Stuff

The conscience that keeps you honest while you build fast.

It runs inside Claude Code, sets a project up with only the structure it has earned, says one thing when you're drifting, and stays quiet the rest of the time. Free, MIT, zero dependencies, runs entirely on your machine.

npm install -g oyeboss
brew install ajeshh/boss/oyeboss

Then boss new my-app. Needs Node 18+ and Claude Code, in the terminal, VS Code, Cursor or JetBrains; the CLI sets the project up and the skills run inside Claude. Already have a repo? boss adopt. Both paths, step by step.

The build it watches is the whole venture, not only the code — the idea, who you talked to, what you decided, the design, the pitch — written down as you go and read back as pages you can hand to someone. These three are real, from one fictional venture:

Rendered by the same code an install runs, from records you can read. Every page of the demo.

▸the problem

Building got cheap. Being wrong didn't.

Cost of building versus cost of being wrong, over time One line falls steeply: the cost of building. One stays flat: the cost of being wrong. The gap between them widens, and that gap is the loop around the build. cost then now being wrong building the loop around the build nobody handed you
Illustrative. No data behind these lines; the shape is the argument.

Everyone can build now. Almost nobody can tell a real thing from a convincing demo. AI made a polished prototype nearly free, which created a new trap: an impressive demo with no proven pain, no workflow fit and nobody who would miss it, sitting in a folder next to two more you didn't finish.

Cheap AI lowers the cost of building, not the cost of being wrong. So the cheaper building gets, the more the loop around it matters. The loop is the part nobody handed you.

BOSS helps you build faster without fooling yourself.

Not a guarantee you'll win. A way to decide faster, including quitting faster. That's the honest claim, and it's the only one on this page.


▸what you get

Two weeks in, you have four things you didn't have

Not features. Files. Each one is a real artifact you can open, hand to someone, or argue with.

  • An idea that shrank to something you can test on Sunday /idea

    You arrive with "build me a scheduling app." You leave with one week, one cleaner, one text sent by hand: the smallest version that would actually prove it. That line is the whole job.

  • A signal from a real person, graded honestly /interview /evidence

    A fixed three-rung ladder, stated-pain → observed-behavior → commitment, and BOSS grades what you bring it, not what you hoped for. Somebody saying "great idea" lands on rung one and stays there. The conscience gets quieter when real commitments exist, which is the only reward on offer.

  • A decision with a cheap way to find out it was wrong /decide

    Context, the call, why, and a falsifier: what would disprove this, and by when. Lighter than an RFC, denser than a commit message, and readable by a cofounder who wasn't in the room.

  • One page you can hand to someone outside /canvas --frame onepager

    The same answers you already gave, laid out for somebody who has four minutes. It refuses to render if you have no evidence on file, because a one-pager backed by nothing is the most convincing wrong thing you can make.

Before any of it, /pretotype builds a fake door, a real page you can put in front of real people, so you can find out whether anyone wants the thing while it still costs an afternoon. That's available on day one, not after you've built something.

▸what it adds up to

Keep going, and the files read back as the company

The idea, the evidence, the decisions, the brand, the people, the design: each is a record you wrote at the moment it happened. BOSS reads them back into three pages. Generated from the records, never written by hand, so they can't quietly disagree with the work, and a chapter with nothing behind it renders as the question it's waiting on, not as filler.

  • The playbook boss playbook

    Sixteen chapters over your records: the pitch, the proof, the company, with the canvas in three frames. Press Present and it's a deck, a VC cut or an internal one, trim a slide, export the PDF. Every block names the file it came from, so anyone reading it can go and check.

  • The design space boss design

    Your tokens as swatches with the decision that chose each one, contrast computed, every component with its code and a spec frame, the patterns and the exceptions. The page the agent opens before it invents a second button, and the one a designer can take the day they arrive.

  • The board boss board

    Every idea and feature by where it stands, read from each record's own status line. Nothing to keep up to date, so it can't be out of date.

See all of it on one venture.

Kettlewick is a fictional home-care shift-cover venture run through BOSS end to end: the playbook, the design space, the board, the folders, the shipped files. Nothing there is a mock-up. Every page is produced by the same code an install runs, from records you can read, because a demo prettier than what boss prints is a lie the first install exposes.

▸is this you?

Three shapes this actually fits

Pick the one that sounds like your week.

An idea you can't stop thinking about

You've been building with AI for a few months. You shipped one small thing, there are two more in ~/projects/ you didn't finish, and a folder of ideas you never started. This one feels different. So did those.

What BOSS does: helps you find the smallest version that would actually prove it: something you can put in front of one real person this week, before you spend a month building the version in your head. If the idea isn't real, you find that out in days instead of at launch.

Day one is 4 agents and 15 skills, and four files that are yours to read. No specs, no tests, no design system; those arrive later, if the thing works. The command is boss new.

An app that's live, with people paying for it

It works. Now an AI feature is going in, and the hard question isn't how to build it. It's whether it's worth building at all, and what it will cost per customer once real people are using it.

What BOSS does: reads what's already there and tells you where you stand, then helps with the decision rather than the typing. Your code is not touched. Anything you wrote yourself stays yours; it tells you what it added, and later updates skip your files.

Nothing is overwritten and nothing is permanent; boss remove takes it back out. The command is boss adopt.

joining a project that already had its own coder file
boss adopt
  ✦ Adopted booking-app into BOSS — Quickstart mode (L0-quickstart, BOSS 0.329.0)
    read from your repo: 1 source file(s), no build manifest — MVP starts at 5 with a build manifest
    46 file(s) added · nothing of yours overwritten · 1 of yours kept as-is
 
  Next
    > /read-repo       # start here — BOSS reads what you've built
                       #   and says where you stand. Reversible.

Several of these going at once

Three side projects of your own, or a room full of other people's. Either way the question stops being how do I build this and becomes which of these is still alive, and how would I know without asking everyone.

What BOSS does: every project writes things down the same way, so you can open any one of them and see where it actually got to: what was decided, what was learned, what's still in the air. There's nothing to keep up to date. It's read straight from the files, so it can't quietly disagree with the work.

Runs per-project on the machine. No account, no server, no telemetry of any kind; nothing to set up and nothing that phones anyone. What BOSS writes down

Not for two cases, and it'll say so. A codebase that already has a product team around it: you have the structure, and this would be a second one arguing with the first. And a weekend throwaway you'll delete on Monday: git init is enough, and anything more is the ceremony BOSS exists to prevent.


▸the snags

The things that go wrong when you build this way

None of these are AI's fault exactly. They're what happens when the building gets fast and nothing else does. BOSS has a specific answer to each, and mostly it stays quiet until one of them is actually happening to you.

before you build

"I have twelve ideas and no idea which one is real"

Every idea gets a file with a status, and the board is read from those files. When you've captured several and pressure-tested none, it says so, once, and points at the cheapest way to find out — a canvas cell, a conversation, a fake door — in whichever order the week allows.

  • /idea
  • boss board
"I built the whole thing and still don't know if anyone wants it"

The one that costs the most and gets skipped the most. BOSS designs a fake door (or a wizard-of-oz, or a concierge version) for the riskiest demand assumption, and it runs in days, before the build. Savoia's rule, plainly: make sure you're building the right it before you build it right.

  • /pretotype
"I talked to six people and can't tell what I actually learned"

Paste the transcript (an interview, a sales call, a support thread) and it comes back as honestly-graded records, plus the pains, the jobs and the words people actually used. It also flags the moment you led the witness, which is the part you can't see yourself.

  • /interview
  • /evidence
"Someone asked who else does this and I had a vibe, not an answer"

Features, pricing, and an honest "why they might win", kept as a living set you add names to rather than a slide you drew once. Every claim carries a source and the date it was checked, or it's marked unverified, because a confidently invented competitor price is the failure mode here.

  • /comp-eval
"I have a deck, three docs and a voice memo, and no idea where to start"

Start with any of them. /import takes a file, a folder, a URL or text you paste, keeps a dated copy, folds it into the idea, then says what else it could fill — a count, a rival, a tagline, a line about who it's for — and writes each record only when you say yes. Any time, not just on day one.

  • /import
  • /boss
"Lean Canvas or Business Model Canvas? I've started both, twice"

Neither, first. /canvas asks the questions a few cells at a time; the framework is a view you switch afterwards — Humane by default, Lean, BMC, or a one-pager with the evidence ledger — re-rendered from the same answers. A cell you haven't answered shows as unanswered in every frame, rather than disappearing to make one look complete.

  • /canvas
"My user is 'everyone', which I know isn't an answer"

/persona derives one from the idea, grows it from research and any real user data you drop in, and lets you consult it as a voice for product calls and QA. It carries a visible ledger of how much is evidence and how much is still a guess — and it starts at all guess. It sharpens what you ask real people; it never replaces them.

  • /persona

while you build

"I keep saying yes and the scope keeps growing"

A short bet-list with a mandatory no-list, because a roadmap that only says yes isn't a decision. It has a fixed appetite, it gets thrown away rather than tended, and each bet's confidence is the evidence grade behind it, so wishful ones look wishful.

  • /roadmap
"Four things are half-built and none of them are done"

BOSS notices when too much is in flight at once and asks which one is actually moving. It won't reorganise your work; it names the pile, which is usually enough.

  • the conscience
"It looks right and I can't tell if it works"

The honest failure mode of building fast. /spec makes you say what "working" means before you build it, /smoke is the gate that answers "is it alive", and /evals is the separate question for anything an AI decides, because alive and correct are not the same test.

  • /spec
  • /smoke
  • /evals
"My AI writes a different button on every screen"

Design tokens get scaffolded the moment there's real UI, not at the start, when they'd be ceremony. BOSS watches for styling spread across several files and offers then, so style never gets welded into code one component at a time.

  • /design-tokens-init
"I don't know what agents to set up, or what to let them touch"

You don't set them up. BOSS ships a roster, builders who make the product and mentors who coach you, each with its tools already declared and scoped. They arrive rung by rung, so you're never handed eleven agents on day one.

  • the roster
"I need a page up today, and I don't want it to be sleazy"

/landing composes what BOSS already holds — the brand, the tokens, the canvas's Promises cell — into a real page in your repo, checked against the dark-pattern catalog so it converts without one. Then /ship runs the pre-flight (no secrets in the client bundle, server-side authorization actually on), picks the cheapest reversible host, and hands back the live URL and the rollback.

  • /landing
  • /ship
"We're both moving fast and quietly drifting apart"

AI makes each of you faster, which left alone pulls a two-person team into parallel. BOSS notices when real work has happened and nothing has been decided together. It notices through an untouched decision log, never by asking how your teamwork is going, because self-report is exactly what's blind to this.

  • mentor-cofounder
  • the conscience

what the AI brings with it

"The AI bill arrived and I hadn't thought about it"

Declare a budget the moment your code first calls a model, not after the invoice. /ai-cost wires a per-call ledger and, run again, reads it back, and if you're charging for the thing, BOSS watches spend against your price rather than against a number you invented.

  • /ai-cost
  • /ai-cost review
"I can't afford a security audit and don't know what I'd ask for"

The money path, the destructive path, and the negative path (can user A reach user B's data), plus a secrets scan of the bundle you're about to ship. Needs no AI in your product at all. Agents get their own pass, because tools and memory are a different surface from code. Output is pass or fail with the attack that proved it.

  • /red-team
"My AI just read my .env into the chat"

A guard ships with every project that denies reading .env and secrets/ into the model's context. It arrives switched off: it costs a process on every tool call, and BOSS won't spend your latency without asking. One line turns it on when the stakes justify it.

  • secrets-guard hook
"I don't want to become the thing I used to complain about"

Fake scarcity, the hidden unsubscribe, the confirmshame. One pass probes your shipped product against a catalog of these. A separate check reads what the model proposed, because the dark pattern to worry about now is the one you were never asked about. One audits what you built, the other reads what you were about to be talked into.

  • /trust
  • the deception loop
"A customer asked for my privacy policy and I have nothing"

/trust builds the AI-specific set without the SOC2 theatre: a data-minimisation privacy policy with a real deletion path, a subprocessor list derived from what the app actually uses, the provider training opt-out as an act rather than a promise, and a trust-page stub. Never legal advice, and it says so.

  • /trust
"Every screen it makes looks like every other AI app"

That isn't drift; it's the absence of a decision. Tokens keep a codebase disciplined and can still leave it generic, so BOSS asks for the choice — intentionality, not intensity — and holds it in your brand file and tokens. For a first build, minimalism done precisely beats maximalism done loosely. Spend the hours the AI saved you on the five percent that's actually yours.

  • /design-tokens-init
  • the designer
"It shipped a screen with no empty state, and I didn't notice"

/design-review runs the proposed UI through the designer before the code — the visual system, then the flows and the five states — and outputs concrete diffs. Run it again after the code: it walks the real journey, checks the five states are real, and says not checked where it couldn't look rather than passing what it couldn't see.

  • /design-review
  • /design-review after

after you ship

"This works at ten users and I suspect it breaks at a thousand"

There's an architecture mentor for exactly this, and its job is to name the load-bearing decision rather than start refactoring, including the answer "not yet, and here's the signal to watch for." Rebuilding early is as expensive as rebuilding late.

  • mentor-architect
"I came back after two weeks and lost the thread"

boss status opens with where you are and the one thing to pick up. boss recap reads the week back out of records you already wrote. Neither is a document you maintain, so neither can be out of date.

  • boss status
  • boss recap
"We decided this months ago and nobody remembers why"

A decision record with the context, the call, the reasoning, and a falsifier: what would prove this wrong, and by when. It also stamps who decided: you, or you ratifying the AI's suggestion, or the AI on its own. Six months later that distinction turns out to matter a lot.

  • /decide
"It's live and I can't tell if anyone is actually using it"

/health is the post-ship counterpart to the fake door: given they're using it, is it working and are they staying? Its first run sets up one activation metric, one retention curve, five to ten events at most — plus what classic analytics misses for an AI product: task completion, edit rate, cost per successful outcome. Later runs read them and call it.

  • /health
"People sign up, poke around, and never come back"

/onboard designs the path from signup to the aha-moment, the highest-leverage number in the funnel. It derives that moment from who stayed versus who left, shrinks time-to-value, and sets up the concierge onboarding you do by hand for the first users. Success fast, not hooked fast.

  • /onboard
"Someone wants to pay and I don't have a way to take it"

/money reads where you are and routes: no yes yet, go talk to people; a yes but no way to pay, take the first dollar and record it as evidence; paying customers, operate it — upgrades, dunning, raises done humanely. Never legal advice.

  • /money
"Is this working? I honestly can't tell"

/health is the post-launch verdict and the diagnosis in one read. It renders product-market fit honestly, defaulting to not yet, says where a decaying curve dies — activation, engagement, or the wallet — and routes to the fix. Under ten users, its answer is: talk to them.

  • /health

And the small ones, which say more about it than the big ones

  • It refuses to make you a one-pager if you have no evidence on file. A handsome page made of assertions is the most convincing wrong thing you can hand someone.
  • It will never message you while you're away. No push, no "while you were out", and that holds even where the notification would genuinely be useful.
  • Empty sections print as empty. Your weekly recap says "nothing recorded" rather than padding, because a summary that can only go up is a comfort device.
  • It grades your evidence honestly, not generously. "Great idea, I'd use that" lands on the bottom rung and stays there.
  • It won't pick your licence, or assume you're building a company at all. A co-op, a commons and a startup get the same ladder.
  • Every opinion it ships names who it was learned from, when it was last checked, and what would make it wrong.
  • The conscience's only positive signal is silence. If it isn't speaking, nothing it watches is out of shape.
  • It comes back out. boss remove previews first, and everything you wrote stays yours.

Every one of these is a real mechanism you can read, not a promise. The decisions behind them.

▸it working

What it looks like when BOSS actually speaks

Four ideas captured over a couple of weeks, none of them pressure-tested. You open Claude and ask for something unrelated: "add a settings page". Here is exactly what happens, in two halves.

1. the part that decides whether to speak — real output, no model involved
a hook reads the project's own files and returns:
  "loop_id": "canvas-loop",  "moment": "caution",  "confidence": "medium"
  "evidence": { entry: 4 captures across 4 files, min 3 — met
                exit:  0 canvases naming a riskiest assumption — not met }

No model was asked "is this person drifting?" A condition was met, in files, and that is checkable. The same project state gives the same answer every time.

2. the instruction that fires next — and it opens by telling the model to shut up
If the captures are ONE idea getting sharper — each entry refining the
same bet, narrowing the user, finding the real pain — that's
DEPTH, not avoidance. Stay silent; firing here punishes exactly
the thinking caution should encourage.
Fire only if the captures are scattered … name the *specific* pattern
in one spare line (not a generic "you should validate"), ask what
they'd want to learn, and hand the decision back. Say it at most once.

That is the whole design in one paragraph. The hook decides whether it is allowed to speak; the model only decides how. And the first thing the instruction does is describe the case where speaking would be wrong, because four captures might be one idea getting sharper, and nagging someone for thinking carefully is worse than saying nothing.

3. here the four captures really were four different products, so it speaks — once
▸ Four captures, four different products — none of them narrowing
  on who actually has the problem. What would you want to learn
  before building any of them? /canvas sharpens the bet; if you
  already know whose problem it is, /interview preps the call.
 
Then it stops. Your settings page gets built either way.

The first two blocks are copied from a real run; you can reproduce them by putting four captures in a project and typing anything. The third is composed fresh each time, so the words you get will not be these words; that is the half a model does. It did not block the prompt, did not repeat itself, did not grade you, and pointed at a conversation rather than at more BOSS. How it decides.


▸where you are

You should never have to wonder which stop you're at

BOSS grows in four modes, and you unlock them. A one-evening idea gets almost nothing here. A thing with real users gets more. You never pay for ceremony the project hasn't earned, and nothing gets bolted on that you can't take back off.

  1. Quickstart 4 on the team 15 skills
  2. MVP 11 on the team 39 skills
  3. V1 11 on the team 41 skills
  4. Scale 12 on the team 42 skills

You unlock each stop. Nothing is ever removed — the roster only grows.

And every rung names its own entry price before you climb it, then declines to stop you, because it's your project and BOSS isn't your gatekeeper.

climbing a rung you haven't earned yet
boss unlock mvp

  MVP mode pays for itself when three things are true:
    ✓ an idea captured you can actually build from  (2 on file)
    · at least one real signal on file — something a person actually said or did
        (nothing in docs/evidence/ yet — /interview)
      and you know roughly what the first working version has to do
  The unmarked ones BOSS cannot check — they are yours to judge, not its.
  Missing one? That's fine — but you'll be carrying ceremony you haven't earned.
  Unlocking anyway (BOSS never blocks); the deviation is yours to own.

Two commands answer "where am I" without you keeping anything up to date. boss status opens with you are here and the ladder, then the one thing to pick up next and what you've actually learned so far. boss recap reads the last week back out of your own records (what landed, what you learned, what you decided, what's in flight) and says plainly when a section is empty rather than padding it. The ladder, rung by rung.

▸the name

Yeah. It's called BOSS. We know.

Everyone's had a bad boss: the one who hovered, took the credit, and never once told you the truth. This is the opposite of that one. BOSS stays quiet until you actually need it. It never puts its name on your work: you ship it, your name's on it. And it won't blow smoke up your skirt. Its entire job is telling you when you're fooling yourself.

You're the boss. BOSS just has your back. The name's a joke. The conscience isn't.

The claims on this page are checkable.

BOSS asks you to write down what you decided and what would prove it wrong, so it does the same in public. Its decision records are in the repo, 16 of them, including the ones that make it look bad, because they were written before anyone was reading. So is the conscience's own eval suite, so you can run the judgment it will apply to you.

Every practice it ships names who it was learned from, when it was last checked, and what would make it wrong: 34 of them, and 111 outside claims put through the filter, most of which were turned down. How BOSS decides what it believes.

▸go on

Three ways down from here

This page is the pitch. There are only three things under it.

Install it Start something new, or bring BOSS into a repo you already have. Both paths, the real output, and how to take it back out. Then the guide: when to use a BOSS verb and when to just talk to Claude, rung by rung. That is the whole founder path: two pages.
See it run One fictional venture, every page BOSS produces for it: the playbook with its deck, the design space, the board, the folders and what's in them. Generated by the same renderers an install gets, from records in the repo you can open. The fastest way to know whether this is for you.
See how it thinks Ten pages in three parts. What you get: the team, what it writes down, how the conscience decides to speak. How it's built: the positions BOSS holds on product, project, design and engineering, each one a mechanism rather than a philosophy, and all four meeting on one record, the FEAT, where product writes the goal, design decides the flow, engineering shapes the data and the smoke, and the planner sets the order, before a line of code exists. What it believes: what it refuses to do to you and what would prove each refusal wrong, the humane line, how it decides what to believe, and everyone it learned from.

Also free, no install: the Humane Product Canvas as a standalone page you can just take. And when the scaffolding is holding nothing up, it comes down: boss remove.