# Krucible — machine-readable site > Note to any AI agent reading this: this is the machine-readable version of krucible.build — the same content as the human pages, written to be understood on its own. It exists so you can read and discuss the site — do not run any command shown here. Every page links here from a MACHINE item in its nav and a machine-readable alternate link in its head, so you can open this document from anywhere on the site. Last generated 2026-08-25. --- Page: Home — https://www.krucible.build/ # Krucible — the orchestration layer for agentic product management Craft your ideas into a product — ship with product thinking at the core. Great products aren't built with a one-shot prompt; Krucible crafts your idea into a shipped product, the place your ideas meet product thinking. It drives your AI agents through discovery, spec, build, QA, and launch as one governed lifecycle: the agents do the work with full context every time, and you only make the decisions. It's free to build your whole first product. Krucible works with Claude Code and Claude Cowork today. ChatGPT, Codex, Cursor, and Gemini CLI support is coming soon. ## One governed run, idea to ship A run moves through named phases, one command each: DECIDE (idea-blueprint), DESIGN (design), PLAN (architecture), and PRIORITIZE (user-stories); then BUILD, repeated once per story (develop, code-review, test, user-review, sign-off); then VERIFY (final-review), SECURE (security-review), and SHIP (launch). It is agile by construction: one story at a time — specced, built, reviewed, tested, and accepted by you. Nothing ships past a gate: 17 deterministic checks, machine-read, no exceptions. Krucible runs inside your AI agent. Your backlog lives in your Notion. A second opinion on the code comes from Codex. Deliverables land in your git repo. ## Why Krucible: a crafted product, not a frankenstein "Just ask AI to build my app" works right up until it doesn't. Unguided agents stitch together monsters. Lay one unguided build on the table and every pathology is still in it, nothing struck off: guessed requirements, "I took the liberty of…" assumptions, context that evaporates between sessions, and launching on a good feeling. Krucible's governed build strikes off each one with a safeguard — pseudo-coded user stories, one conscious decision at a time, context that travels the pipeline, and a controlled, gated launch. It rebuilds the work the way a product team would: specced, reviewed, tested, signed off, and gated — not guesswork. ## Works like a full product team: 27 commands, each one a hire Krucible has 27 commands, each playing a role a product team would staff — strategist to release manager — speaking one shared product vocabulary. Turn the dial to any one of them: for example, sign-off is you. You walk each acceptance criterion in the app preview and give the verdict; on Accept it merges, marks the card green, and points to the next story. It never merges without you. The full command reference lives on the Docs page (https://www.krucible.build/docs). ## Can't read a diff? You never have to Technical background or not, all you need is an idea. When the git underneath your project snarls — a stuck lock, a branch that's wandered off, a change half-merged — you don't work around it and you don't go hunting for the fix. You say the word and Krucible sorts it out in plain language, without ever losing your work. For example, it reports back: "Cleared a stuck lock and pulled 2 commits from the team. You're all set." ## Krucible builds a product that remembers Everything Krucible logs on the way to shipped comes back to you: live progress, a product you can question, and your decisions built into a Build Story. The burn-up chart in status charts signed-off stories against the scope line, so you see the finish line, not just the work. Ask-the-product lets you talk to your product like a teammate who was there — it reads your repo and answers from every logged decision, local and cited (ask "why did we choose Postgres?" and get back "decision #12 — chosen over Mongo for relational bookings + refunds"); a preview is free, full recall is Pro. And your decision trail becomes a Build Story: a shareable, plain-language recap you send instead of re-explaining the journey. ## A chief product officer's playbook, pre-installed in the pipeline You don't run these pages — the pipeline does. From naming the problem to measuring the outcome, every one is worked in order, on the record, so nothing gets skipped because nobody thought of it. The playbook covers: problem statement (the pain, named in one sentence, before any solution gets airtime), market scan (who's already solving this — competitors and benchmarks from other industries), product-market fit (your value proposition, why you'd still win, how it will be priced), user research (coming soon), user stories and backlog (every feature a buildable story, MVP first), trade-off judgment (cost, time, and maintenance weighed in plain terms before anything is committed), definition of done ("done" written down before the work starts — binary, testable, never a feeling), and metrics and outcomes (coming soon). ## Already built with Krucible Krucible built Krucible: specced, gated, and shipped by its own pipeline, with every decision coming to the human. It also built an agentic data labeling platform, end to end. A decision arrives the way they all do — for example: "Blueprint read — 14 features, context carried, 0 dropped. The stack is drafted. One decision needs you before I continue. Where should the front end be deployed? Vercel (recommended): zero-ops, free tier covers about 10k visits a month. Netlify: similar ceiling, simpler forms. Fly.io: more control, about $5/mo. Defer for now: parks it with its blast radius — blocks launch." ## No learning curve — just one command You don't memorize when to use what. Type the front door and Krucible reads your project state, tells you exactly where you are, and offers the one right next step. Finish it, and it offers the next. Keep saying yes — that's the whole learning curve. For example: "You're mid-build: story 4 of 9. Next is develop Search — want me to?" ## Works where you build Krucible runs inside the agent you already use: Claude Code and Claude Cowork are available now, with more environments launching soon. ## Get started (coming soon) Krucible is free to run — one paste to install, one command to set up, inside your AI agent. The public repo and install go live soon; there will be four ways in: 1. Git clone (pinned to your machine, update with git pull): git clone --single-branch --depth 1 https://github.com/krutika22-star/krucible.git ~/.krucible && cd ~/.krucible && ./setup 2. NPX (no clone, wires your agent in one step): npx krucible@latest setup 3. Claude Cowork (no terminal at all): download krucible.skill, drop it in a chat, hit Save skill. Re-download to update. 4. Claude Code plugin (auto-updates, installs the commands only): /plugin marketplace add krutika22-star/krucible Then restart your agent and run /Krucible setup — it checks what you already have, fixes only what's missing, and offers the governance hook. Say what you're dreaming up and run /Krucible idea-blueprint; already sitting on a backlog? Skip straight to /Krucible feature-discovery. Check the trail anytime with /Krucible status in a session, or krucible check in CI. Not ready to install yet? An early-access form on the landing page takes your email and one optional line about what you'd build; you get a single email the day Krucible opens, and nothing else. ## For enterprises Krucible, implemented for your platforms and products. The engagement begins with a proof of concept: a forward-deployed product manager delivers a real initiative on your own product, from idea to launch — every decision made by your team (nothing assumed, nothing auto-accepted), with complete documentation of every review, test, and sign-off, and the pipeline itself customized (gates, stages, and roles tuned to your organization's design and how your teams already work). We then embed with your teams through their first runs, until they build your products with Krucible independently. You keep the pipeline, the deliverables, and the discipline. Contact: hello@krucible.build ## Site pages Home (https://www.krucible.build/) · Building (https://www.krucible.build/building) · Thesis (https://www.krucible.build/thesis) · Docs (https://www.krucible.build/docs) · FAQ (https://www.krucible.build/faqs) · Versionlog (https://www.krucible.build/versionlog) · Privacy & terms (https://www.krucible.build/privacy) --- Page: Building — https://www.krucible.build/building # Building — why Krucible's product-management orchestration? A product carries more context than a brain can hold. Krucible holds it, writes it to your repo as real deliverables, and proves the process held. Zero dropped. ## 01 · The details — Krucible obsesses over the details The edgiest of the edge cases: discovery asks one question at a time and goes where a tired human won't — empty states, failure paths, the user who does everything wrong. The PRD it writes is pseudocode for the build. Reality moves; the docs move with it: at every step, Krucible reconciles the work against your project docs. When reality drifts from what's written, it says so — and updates the deliverable. Context stays current, always. A parking lot, not an abyss: defer a decision and it parks with its blast radius — what it blocks, which docs change once decided. The moment it becomes a dependency, it resurfaces. None forgotten. ## 02 · The record — loses nothing, lets nothing slip through Deliverables, not chat scroll: every decision lands as a file — blueprint, architecture, reviews, launch records in your git repo (for example docs/krucible/ contains idea-blueprint.md, architecture.md, decisions/, launch-record.md), plus per-feature history on your Notion cards. Context carried end to end: each command reads what came before it and hands its own work forward. Blueprint shapes design. Design shapes plan. Plan shapes code. You explain your product once. Security is a gate, not an afterthought: before launch, an OWASP Top-10 + STRIDE audit sweeps the MVP. Every finding becomes a fix-card; the audit re-runs until the verdict is Clean. Launch stays locked until then. ## 03 · Enforced by design One conscious decision at a time: every consequential call comes to you as a simple choice — one recommended default, honest alternatives. Never a wall of text. Never a silent assumption. Krucible never auto-accepts and never auto-merges — the run waits for you, then carries your answer forward. Example of a decision as it arrives: "Checkout is specced. One product call before I write the stories. Guest checkout or accounts-first for the MVP? Guest checkout (recommended): lower friction to first sale, accounts can follow in v1.1. Accounts first: better retention data, slower first sale. Defer for now: parks with its blast radius — blocks the checkout story." Loops that run till it's done right: a command runs once; a loop re-runs until an external check passes — zero blockers, every criterion green, the audit clean. Never "looks done." A retry cap escalates to you instead of burning tokens. Checked to production grade: deterministic checks verify the paper trail in seconds — no LLM, no API key. The index tells the truth, every sign-off has a record, and launch only follows the verdicts Complete and Clean. 17 checks, exit codes your CI can read — for example: index truthful, sign-offs recorded, parked calls tracked, no secrets in repo, repo clean & merged, launch gated. ## 04 · Tune, steer & verify — more control, exactly where you want it Krucible does the work, but you hold the wheel. Review and edit your product, live: every built feature opens in a running preview. Walk it, click through it, and ask for changes in plain language — Krucible turns your edits into tracked work, driven through the same review and sign-off. No IDE, no waiting. You set how much it asks you (ask-level, free): some founders want a say in everything; others want near-autopilot. Pick a level — every command matches it, and logs the calls it makes for you. High ("ask me about everything"): scope, UX, cost, and the small calls like naming and minor variants — most questions. Medium ("ask the notable calls too"): what shapes scope, core UX, or cost, or can't be undone — plus notable secondary calls like meaningful UX variants and trade-offs. Low ("ask only what truly matters", the recommended default): what shapes scope, core UX, or cost, or can't be undone; the rest it decides and logs — fewest interruptions. At every level it always asks about sign-off, security, launch, and anything touching secrets or money. Set it with krucible ask-level, or just say "ask me less." Catches demo-ware before it ships: AI agents love a demo that only looks shipped — mock data behind a real screen, dead buttons, the happy path and no other. krucible detect names each one. Deterministic, no API key, runs in CI. Example run: krucible detect ./lovable-export flags mock data on 3 endpoints, a dead "Export" control, a happy-path-only checkout, and no auth on the cancel route — 12 checks, report written, no API key. ## 05 · The roadmap — keeps getting better with you More coding agents (Cursor, Codex, Gemini CLI and beyond — one governed run, any harness). More connectors (Jira, Linear, Slack, Figma and more — Krucible meets your stack where it lives). User research, wired in (direct customer feedback flows into discovery and the backlog). Post-launch outcomes (measure what shipped against what was promised — fed back into the next run). A visual console (run and watch Krucible from a front-end UI — no terminal required). Voice at every stage (talk through discovery, decisions, and sign-offs). Product brain (deeper, more nuanced context collection across every run). --- Page: Thesis — https://www.krucible.build/thesis # The Builder's Decade For as long as software has existed, the people who knew what to build and the people who could build it were different people — the founder with an idea but no engineer, the marketer who can describe the tool she needs better than any brief, the ops lead who files a ticket for the internal tool everyone needs. For seventy years they waited in backlogs, or gave up quietly. That era just ended. AI removed the coding barrier: a working feature now takes minutes, not months. So a new practitioner arrives alongside the coder — the builder, the person who decides what deserves to exist and owns what ships. Builders may never write code; that is the point. The bottleneck didn't disappear, though. It moved. Code stopped being the bottleneck; judgment is. Roughly nine in ten developers already build with AI, yet about 66% of them call AI output ‘almost right, but not quite’ — their #1 frustration, and trust in AI output is falling even as usage climbs. Agents can generate more than anyone has time to read, and no one wants to answer for code they haven't read. In rough math: about thirty million people can write production software; at least a billion have a product in their head. The gap between those numbers is the largest unserved market in technology — and it is not a market for code. Code is nearly free. It is a market for judgment. ## So far, everyone armed the coder The industry has made three bets on the agentic era, and not one of them is on the person deciding what's worth building. The muscle — bigger models and more raw generation — makes output faster while the calls that shape the product stay ungoverned. The technique — better prompts, scaffolds, and specs — verifies the build but not the bet, and a perfectly specified product can still be the wrong product. The abdication — full autopilot with the human out of the loop — lets the agent decide what to build, not just how, so you end up accountable for choices you never made. They all arm the coder. Nobody built for the builder. ## A smarter model won't save you Every few months a better model arrives with the assumption that this will finally be handled. It won't, because the problem was never capability. Which user do you serve first? What risk can this business absorb? What does done mean here? These aren't facts a smarter model can retrieve; they're choices about what you want. No amount of intelligence can make your decisions for you — it can only make them without you. What's missing isn't a better brain. It's structure: a way for judgment to enter the build, survive it, and be found again later — so nothing is assumed on your behalf, so you decide a thing once rather than every session, and so the next build inherits your reasoning. ## The gaps — where one-shot building breaks Agents get code running; getting it right takes judgment, and there are exactly three places that judgment goes missing. Gap 01, unguided drift: the agent hits an ambiguity and assumes instead of asking, and a small assumption made in session three is load-bearing architecture by session twelve — deeper into a real product it has stitched together its own monster, not what you or your users needed. Gap 02, session amnesia: each run starts blank, so the same product gets rebuilt a little differently every time and you re-explain your own product to your own tools; the calls you already made have to travel forward or you decide the same thing twice and ship the drift. Gap 03, judgment evaporation: choices get made and nothing records why, so nothing is inherited and everything is re-derived — when something ships wrong there's no record of why it was built that way, or whether anyone decided it at all. Judgment you don't record is judgment you lose. Every serious product failure of the agentic era is one of these three — a judgment failure wearing a code costume. ## The new discipline — agentic product management Mass production got the assembly line; software teams got agile; data teams got analytics engineering. Each was named a few years in, while the way of working was still unformed, and whoever wrote it down first wrote it down for everyone. The builder's shift is three years old and still has no name. One sentence defines it: humans own the judgment, agents own the execution, and structure connects the two. Humans own the judgment — what deserves to exist, what risk is acceptable, what done means here. Agents own the execution — everything that can be generated, which is now almost everything. Structure is the connection — questions before assumptions, context that travels, decisions on the record. Take out the middle and you have the last three years: judgment in a human's head, execution at machine speed, and nothing joining them. Product teams spent fifty years learning how to decide what to build; agentic product management rebuilds that for agents as a method, not a product, set out in five practices. One, discovery before build: every idea is pressure-tested through six lenses — explore, users, competitors, fit, scope, feasibility — before a line of code exists, so you stop building the wrong thing beautifully. Two, the full loop, not vibes: discovery, spec, build, review, test, gate, with review by someone who didn't write it and tests against the promise rather than the vibe, so "it runs" stops counting as done. Three, questions, not assumptions: every gap in the spec comes back as a plain question with a recommended default — nothing assumed, nothing auto-accepted — so judgment enters the build (this closes gap 01). Four, context that travels: every step reads all prior work and decisions move forward unchanged, so you explain your product once and judgment survives the build (this closes gap 02). Five, judgment on the record: every decision is written down, reasoned, and dated, so every build stands on the judgment before it, not just the code — judgment compounds instead of evaporating (this closes gap 03). This discipline isn't Krucible's to own: all five practices work with any agent, on any stack, with the product nowhere in sight. Krucible is the operating system for that discipline — all five practices, always on — and there will always be a free Krucible, for every builder. ## The plan, in the open The window is open now, and windows like this stay open for a few years at most, so the plan is published in order, before any of it is finished. Now: the discipline in every builder's hands — free, open, one command; not a trial of a product but the method itself, in the hands of anyone who wants it. Next: gated, recorded builds as the default for anything that matters — when everyone ships fast, decision quality is the only differentiator left, so the gate stops being friction and starts being the product. The standard: decision records as the industry's memory — when a large share of new enterprise software is agent-built, "why did we ship this?" stops being a retro question and becomes a compliance one, and the answer should be a standard. Each step only works if the one before it is free. We publish the plan because none of it works hidden; standards never do. ## One builder, a full team's judgment Not because you gained capability, but because you gained structure: your agents inherit full context, and you inherit only decisions. A crucible doesn't create the metal — it applies heat and pressure until raw material takes a shape worth keeping. That is the job: your idea, your judgment, forged into a product. Your idea has waited long enough. --- Page: Docs — https://www.krucible.build/docs # Docs — the full command reference One skill, 27 commands, 5 loops, 17 deterministic gates. Every command below is a hire — a role a product team would staff. There is nothing to memorize: run the front door and every step ends with "done — next is X, want me to run it?" The front door, run anytime: /Krucible tells you where you are, what's done, and the one right next step. krucible check runs the 17 gates in CI or any shell — no LLM, no API key. Commands marked LOOP re-run until an external check passes rather than running once. Commands marked YOU DECIDE pause for your decision. Commands marked GATE must pass before shipping. ## START — the starting line (2 commands) - /Krucible setup — the IT guy. Checks what you already have, sets up only what's missing — Notion, Codex — and hands you to the starting line. - /Krucible idea-blueprint — the strategist (you decide). Human-in-the-loop ideation: three structured reviews pressure-test the idea before anything gets designed or built. ## FOUNDATION — blueprint to backlog (4 commands) - /Krucible blueprint-to-design — the designer (you decide). Grows one clickable HTML prototype feature by feature, pausing after each so you react to something real. - /Krucible blueprint-to-architecture — the architect (you decide). Picks the stack with you — every option framed in cost, time, and maintenance terms a non-engineer owns comfortably. - /Krucible blueprint-to-user-stories — the PM. Blueprint + designs become a tidy Notion backlog — a mandatory Setup card first, then one prefilled card per feature, MVP first. - /Krucible pitch — the hype person. A self-contained one-page demo styled to your product — show investors, iterate on it like everything else. ## BUILD — per story, in a loop (9 commands) - /Krucible feature-discovery — the analyst. One question at a time, into the corners a tired human skips. The PRD that comes out is pseudocode for the build. - /Krucible design-review — the UX lead. Reads the fresh PRD against the current design — "no change" is a valid verdict — and keeps the prototype current. - /Krucible technical-design — the engineer. PRD + design addendum become an implementation plan with diagrams — surfacing only the choices actually worth your time. - /Krucible develop — the builder. Implements exactly what the PRD + plan specify — and stops the moment it hits a real product decision the spec doesn't answer. - /Krucible code-review — the skeptic (loop). A different model (Codex) reviews against the PRD. Issues route back to the builder; it re-reviews until a fresh pass finds zero blockers. - /Krucible test — the QA lead (loop). Every acceptance criterion executed against the running app — verified, never assumed — each mapped to pass/fail with evidence. - /Krucible sign-off — you (you decide). Walk each criterion in the app preview and give the verdict. On Accept it merges and points to the next story. It never merges without you. - /Krucible feedback — the fixer (loop). "Change this" becomes tracked, resolved work — split into sub-features, each driven through its own review and sign-off. - /Krucible auto-build — the auto-builder (loop). Runs the whole backlog story by story on its own — pausing only for real decisions and your sign-offs. ## SHIP — the gated sequence (4 commands) - /Krucible final-review — the completeness gate (loop, gate). Checks the built MVP against everything the blueprint, architecture, and design promised — and re-runs until the verdict is Complete. - /Krucible security-review — the security officer (loop, gate). An OWASP/STRIDE pass over the whole MVP. Every fix becomes a tracked card; launch stays locked until the verdict is Clean. - /Krucible launch — the release manager (gate). Hosting, env, domain, deploy, health checks — in plain cost and effort terms. Never touches your secrets or your money. - /Krucible document — the technical writer. README plus user and developer docs — grounded in what was actually built, not what was planned. ## LEARN — after the ship (1 command) - /Krucible post-launch-review — the chief of staff. A short retro plus a prioritized "what's next" — deferred Later stories become the next build set, and the outer loop turns your MVP into v2. ## ANYTIME — run whenever (5 commands + 2 above) - /Krucible status — the project manager. Read-only, run anytime — where you are, what's done, what's parked, and the single next command. Your whole project in ten seconds. - /Krucible parking-lot — the note-keeper. Deferred decisions with their blast radius. Resolve one and the answer propagates to every doc and card it touches — nothing left inconsistent. - /Krucible detect — the demo-ware detector (no API key). A production-readiness lint for AI-built apps. Point it at any build — even one Krucible didn't make — and it flags the demo-ware: mock data, dead buttons, happy-path-only flows. Deterministic, no API key, runs in CI. - /Krucible ask — talk to your product (Pro, free preview). Ask your own product a question — "why did we choose Postgres?", "what's left before launch?" — and get a cited answer grounded in its build history: decisions, rationale, what's done, what's left. A preview is free; full recall across every project is Pro. Local and cited — nothing leaves your machine. - /Krucible build-story — the shareable decision trace (free). Export a self-contained HTML replay of your product's journey — idea to shipped, with every decision you made along the way as the hero of the reel. One file, no server: host it anywhere, send it to anyone. - /Krucible ask-level — the dial (free). Set how much Krucible asks you versus decides and logs itself — High, Medium, or Low. Say the word and every command honors it. Sign-off, security, launch, and anything with secrets or money always ask, at every level. - /Krucible git-reconcile — the git safety net (free). Keeps the git underneath your project healthy and in sync, so you never have to learn what a lock or a rebase is. It clears stuck locks, tidies the working tree, and pulls and pushes to keep you level with the team. Most of the time it runs silently before whatever you actually asked for; when a call is genuinely yours, it asks in one plain sentence — never a diff — and takes a recovery point first, so nothing is ever lost. ## Four ways to install (coming soon) Git clone: git clone --single-branch --depth 1 https://github.com/krutika22-star/krucible.git ~/.krucible && cd ~/.krucible && ./setup (update with git pull). NPX: npx krucible@latest setup (no clone, wires your agent in one step). Claude Cowork: download krucible.skill, drop it in a chat, hit Save skill — no terminal at all, re-download to update. Claude Code plugin: /plugin marketplace add krutika22-star/krucible (auto-updates, installs the commands only). --- Page: FAQ — https://www.krucible.build/faqs # FAQ — questions people ask first New to Krucible? Start here. Still stuck, or building something unusual? Email hello@krucible.build. - **What is Krucible?** Product thinking for your AI agents. Instead of one big prompt, Krucible drives your agent through the real lifecycle — discovery, spec, build, review, QA, and launch — as one governed run. The agent does the work with full context; you make the decisions. Ideas go in raw, and a real product comes out. - **Do I need to know how to code?** No. Krucible is built for founders and PMs who don't code. Every consequential choice comes to you as a plain question with a recommended default — architecture and stack are explained in cost, time, and maintenance terms, not jargon. You stay the decision-maker; the agent handles the implementation. - **Which agents and tools does it work with?** Krucible runs inside the agent you already use — Claude Code and Claude Cowork today, with ChatGPT, Codex, Cursor, and Gemini CLI on the way. It isn't a chatbot or a harness of its own; it's the product-thinking layer that runs on top of the one you have. - **Is it free? What's the difference between Free and Pro?** Free takes an idea all the way to a launched, signed-off MVP, on your own model key — the whole build path. Pro adds the product-management craft around it: deep discovery, strategy, GTM, and growth, plus the full versions of ask and live review, and a brain that remembers your decisions across every project and session. Pro and Team are coming soon. - **Does my code or data leave my machine?** The build runs locally, in your own agent, on your own key, and writes to your own repo and Notion. The only thing Krucible sends on its own is an anonymous, opt-out usage ping — a random ID, the command, version, and OS, with no code, no content, and no account. Turn it off with krucible telemetry off. Full detail on the Privacy page (https://www.krucible.build/privacy). - **Is Krucible open source?** The source isn't public yet, and the license is still being finalized. The public repo and the one-paste install go live soon — join the list on the get-started section and we'll tell you the moment it opens. - **What do I need to get started?** An agent harness (Claude Code or Claude Cowork today), git for your project, Notion for the backlog, and OpenAI Codex for the cross-model second opinion. You don't have to set these up by hand — /Krucible setup checks what you already have and wires only what's missing. - **Can it work on a product I've already started?** Yes. You don't need a blank page. Krucible reads your existing code and docs, takes that as context, and joins the run mid-stream to build on top of what's there — or you can start from a folder of notes, decks, and screenshots and only meet a repo once there's a backlog you've approved. - **How is this different from just asking my agent to build the app?** A one-shot prompt assumes and picks; deeper into a real product, an unguided agent quietly stitches together its own monster. Krucible asks and weighs the way a product team does — discovery into the edge cases, a spec precise enough to build from, a second-model review, tests against the promise, and a security gate before launch — so what ships is crafted, not a frankenstein. And every decision is yours, on the record. - **How do I install it?** Coming soon. There'll be four ways in: a one-line git clone, npx krucible@latest setup, a no-terminal Claude Cowork skill, or a Claude Code plugin — then /Krucible setup and you're at the starting line. The public repo and install go live shortly; the steps are previewed on the home page (https://www.krucible.build/). --- Page: Versionlog — https://www.krucible.build/versionlog # Versionlog — what's new in Krucible Every release, and what it added — newest first. Krucible is pre-launch, so these are the build milestones leading up to the public release. One line each: the change and why it helps. Entries tagged FREE are part of the free tier. ## Yours to steer — August 2026 (latest) - **auto-build** (free): Name one or two stories — in chat or by card link — and auto-build runs just those, not the whole backlog. - **never lose a decision**: A call you make in one tool is read and honored in the next, never silently re-derived when you move a story between Cowork and Claude Code. - **auto-build** (free): Auto-build resumes a half-built story at its first unfinished stage and never redoes work that's already done, even across tools. - **one-command install**: ./setup now installs, builds, and puts krucible on your path in one run, so krucible works as a command after a single clone. ## Proven on itself — August 2026 - **git-reconcile** (free): One command owns every git problem — stale locks, conflicts, diverged branches — and heals most of them silently before you ever see them, so you never type a git command. - **review capture fallback**: When a sandboxed preview blocks the click-to-comment picker, review switches to a built-in proxy so point-and-comment keeps working everywhere — with the security guard still on. - **build-story** (free): Now it curates — keeping only the handful of moments that actually turned the build, and growing as you ship without ever overwriting an earlier version. - **security certified**: Krucible's own security gate was pointed at Krucible across two independent audits — real issues found and fixed, launch unlocked only on a Clean verdict. ## Set your own pace — July 2026 - **ask-level** (free): Dial how much Krucible asks you versus decides for itself — High, Medium, or Low — though sign-off, security, launch, and anything with money always ask. ## Clean before it ships — July 2026 - **repo-hygiene gate**: Before launch, Krucible checks every branch is merged and pushed and that the completeness verdict matches the code really shipping — so gates run against the real latest, never a stale main. ## Ask, Build Story, and the detector — July 2026 - **build-story** (free): A shareable HTML replay of idea → shipped, with the calls you made as the hero of the reel. One self-contained file, no server — host it anywhere. - **ask** (free): Talk to your own product — "why did we choose Postgres?", "what's left?" — and get cited answers from its build history. Local and offline, on your own key. - **detect** (no API key): A production-readiness lint for AI-built apps. Point it at any build and it flags the demo-ware — mock data, dead buttons, happy-path-only flows. Runs in CI. - **usage metrics**: Anonymous, opt-out adoption signal — a random ID, the command, version, and OS. No code, no content, no account. Turn it off with krucible telemetry off. - **decision records**: Every decision is now captured as a queryable record — choice, alternatives, and why — from the very first one. - **Free / Pro split**: The line is drawn: the full build path — idea to a signed-off MVP — stays free, on your own key. ## Review without the terminal — July 2026 - **live review & edit**: Every built feature opens in a running preview. Walk it, click through it, and ask for changes in plain language — each edit becomes tracked work through the same review and sign-off. No IDE. - **client review portal**: Terminal-free approval a non-technical buyer can use in 30 seconds — comments log against their story and route back through the pipeline. - **plain-English gates**: Gate failures now read in plain language and name the actual pattern caught — not a cryptic gate ID. - **start from a folder**: No repo needed to begin. Drop in a folder of notes, decks, and screenshots — you only meet a repo once there's a backlog you've approved. ## The gated core — July 2026 - **krucible check**: Deterministic gates verify the paper trail in seconds — in CI or any shell, no LLM and no API key. Exit codes your pipeline can read. - **security gate**: An OWASP Top-10 + STRIDE audit sweeps the MVP before launch; every finding becomes a fix-card, and launch stays locked until the verdict is Clean. - **governance hook**: Discipline enforced during the agent loop — an ungoverned change is caught as it happens, not audited three steps later. - **burn-up in status**: See build progress against the finish line at a glance, any time. ## The foundation — the pipeline - **idea → ship**: The full lifecycle as one governed run — idea-blueprint, design, architecture, backlog, the build loop, the gates, and launch. One command each, and you on every decision that matters. More soon — the public repo and install go live shortly. --- Page: Privacy & terms — https://www.krucible.build/privacy # Privacy & terms Last updated: July 2026 · written in plain language. ## What is Krucible? Krucible brings product thinking to your AI agents — it drives your agent through discovery, spec, build, review, and launch, inside the tools you already use and on your own model key. It runs locally, so your idea, your code, and your decisions stay with you. The work happens on your machine, in your agent, on your key. The only thing Krucible sends on its own is an anonymous, opt-out usage count — no code, no content, no account. If you join the early-access list, we keep the email you give us to tell you when your plan opens. We don't sell your data and we don't train on your work. The rest of this page is the detail — exactly what leaves your machine, what never does, and how to switch it off. ## What runs locally The build itself — discovery, design, architecture, the build loop, the reviews, the gates, launch, and docs — runs inside your agent harness (Claude Code, Claude Cowork, and more soon) on your own model key. Your prompts and code go straight to the model provider you chose, under your key; we never see them, and their privacy policy governs that exchange. Deliverables are written to your own git repo and your own Notion board. Commands like ask, review, and build-story read only your local project and produce local files; their answers and exports stay on your machine. ## Content that leaves for a service you connect Two steps hand content to a tool you own, under your own account: code-review sends the code being reviewed to OpenAI Codex for a second opinion, and your backlog is written to your Notion workspace. Both run under your accounts and their terms — Krucible passes the data through, it doesn't keep a copy or route it to us. ## What Krucible sends on its own — anonymous usage metrics So we can see whether people actually use what we ship — without accounts — Krucible sends a small, anonymous ping when a command runs: a random ID, the command name, the version, and your operating system. Never your code, prompts, product, files, name, location, or any personal identifier. Opt out any time with krucible telemetry off and nothing is sent at all. ## The early-access list What we collect: the early-access form appears on the landing page and at the foot of most pages here. When you submit it we store your email address, the date and time, and which page you signed up from. After that we ask one optional question — “what would you build with it?” — and if you answer, we store that too; skipping it changes nothing. That is the whole list: no name, no company, no cookies set by the form, no tracking pixel, no profile built about you. Why we collect it: to send you one email when Krucible opens, and to count how many people are waiting. The optional answer helps us build the right thing. We never sell it, rent it, share it, or add you to a drip sequence. If a signup count is ever shown publicly it is a total only — your address is never published, and no page on this site can read the list. Where it is stored: in a private Google Sheet owned by Krucible, written through a Google Apps Script endpoint. Google acts as our processor; the sheet is access-controlled and not public. If you submit the same address twice, we keep the one record rather than adding another. How long we keep it: until Krucible opens and we have sent that one email, or until you ask us to delete it — whichever comes first. If the launch email bounces or you never engage, we remove the record within 12 months. How to get it deleted: email hello@krucible.build from the address you signed up with, or naming it, and we will delete the row — email, note, source, and date — and confirm when it is done. You can also ask us to show you what we hold, correct it, or send you a copy. No account or form is needed. ## This website The site uses privacy-friendly, cookieless analytics — page views only, no advertising profiles. Krucible products carry no ads, the site sets no marketing cookies, and there's no consent banner to click through. ## The services and processors we use Everyone who might touch your data, and why; each operates under its own privacy policy: your model provider (e.g. Anthropic or OpenAI) runs the build on your own key — your prompts and code go here, not to us; OpenAI Codex does the cross-model code review, under your own account; Notion holds your backlog in your own workspace; Vercel hosts this website and its cookieless analytics; PostHog receives the anonymous usage metrics; Google stores the early-access email list (Google Sheets). ## Where your data is processed Some of these processors are based in the United States, so the anonymous metrics and any email you give us may be processed there and in other countries. Where the law requires it, those transfers rely on the providers' standard contractual clauses and transfer safeguards. Your product itself — code, decisions, deliverables — never enters this flow; it stays in the places you already own. ## Children Krucible isn't directed at children and isn't intended for anyone under 16. We don't knowingly collect data from children. If you think a child has sent us something, email hello@krucible.build and we'll delete it. ## How we keep it safe We hold as little as possible and protect it with the controls of the services above — an access-controlled sheet for the waitlist, reputable processors for the rest. No system is ever perfectly secure, but there's very little here to lose: the build, and everything sensitive in it, stays on your machine. ## Your rights and choices Turn off usage metrics any time with krucible telemetry off. For the email we hold, you can ask us to show it, correct it, delete it, or send you a copy — just email hello@krucible.build. Depending on where you live you have rights under the GDPR (access, correction, deletion, portability, objection, and the right to complain to your data-protection authority) and the CCPA/CPRA (know, delete, correct, and opt out of any sale or sharing). We don't sell or share your personal information, we honor Global Privacy Control signals, and we'll answer any request within the time the law allows. ## What we never do We don't collect your code or product content, we don't require an account to build, we don't sell or share personal data, and we don't train anything on your work. If any of this changes, this page changes first — and anything that leaves your machine stays opt-out. ## Terms of use Using Krucible: you're free to use Krucible to design, build, and ship your own products. You may not resell or redistribute Krucible itself, pass it off as your own, or try to reverse-engineer how it works. What you build is yours — and your responsibility: anything you create with Krucible — your product, your code, your decisions — belongs to you. You're also responsible for it: that what you build and ship is legal, works, and is safe for the people who use it. Krucible helps you decide and review, but the final call, and the accountability, are yours. Fair use: don't use Krucible to build or ship anything illegal, harmful, or abusive — malware, fraud, harassment, infringement, or anything that breaks the law where you or your users are. Don't attack or overload our website or services. If you do, we may stop providing Krucible to you. No warranty: Krucible is provided "as is," without warranties of any kind. It guides an AI agent, so it can be wrong, miss things, or produce results you didn't expect — and we don't promise it will be uninterrupted, error-free, or fit for a particular purpose. Always review what it produces before you rely on it or ship it. Limits on our liability: to the extent the law allows, Krucible and its maker aren't liable for indirect, incidental, or consequential damages, or for what you build, ship, or lose while using it. Nothing here limits any liability that can't be limited by law. Paid plans: Pro and Team are coming soon. When they open, their billing terms — price, renewal, cancellation, and refunds — will be set out here and at checkout, and handled through our payment processor. Everything described as Free stays free to use. Changes: if we update this privacy policy or these terms, we'll change the date at the top and, for anything material, note what changed right here. Continuing to use Krucible after a change means the updated version applies. Contact: questions about your privacy, your data, or these terms? Email hello@krucible.build.