Code Factory

Catch AI-generated tests that could never fail — before review.

Free, local proof for code built with AI. Start from a plain-language outcome, a fuzzy PRD, or a risky diff. Code Factory binds the declared intent, challenges whether a test can actually reject the failure it claims to cover, and shows the current proof gap plus the next human decision. Tests that only look green are not proof: a starter is never called production-ready before the relevant proof exists.

factory mvp "Build an approval tracker" --root .

See actual Factory Studio or open the live Hugging Face Space.

What it does

• Start a real project. Turn one outcome into a contained web, mobile, API, CLI, worker, MCP, or agent-UI starting state.
• Review what AI produced. Turn requirements, diffs, proofs, and blockers into receipts, Graph Ops, and one fact-derived next action.
• Refresh the evidence that matters. Watch a local Assembly while it runs, refresh the next-proof brief, and see privacy-bounded observed Git contribution context without pretending it is a verified directory or billing roster.
• Keep "done" honest. Challenge declared validators for hollow tests; a green-looking scaffold is never called production-ready by default.
• Stop vague work before it starts. Use Intake Grill to record framework, exact intent, observable acceptance evidence, and the external-effects boundary before a Product Mission begins.
• Make a behavior survive its declared failure cases. Use the supervised Gauntlet to turn human-written E2E sabotage cases into an offline-verifiable Survival Card. A hollow negative check stays visible; a card is never a production-readiness certificate.
• Let autonomy be earned, not assumed. Use factory license to derive an expiry-bound local tier from independently verified governed runs. A severe hollow-test, hollow-validator, or scope-escape result demotes the declared agent automatically; it never authenticates identity or grants execution.
• Compare agents with receipts, not vibes. Use factory combine to rank completed, sealed, independently verified runs on the same task. It never starts an agent or turns a local scoreboard into a vendor-quality claim.

What the latest upgrade resolves

These are local evidence and supervision tools, not guarantees of performance, security, productivity, production readiness, or an automatic repair service.

For teams: use the Teams and Enterprise Operations Manual to run the same proof-first loop with named reviewers, approved AI-change scope, and explicit Proof Debt—without giving Code Factory merge, release, or provider authority. The commercial packaging guide keeps the free core separate from proposed Team and Enterprise services that are not purchasable yet. For a human-selected, customer-managed reference pilot, the local Team Pilot readiness gate hash-binds the operating evidence for owner review; it does not accept a customer or activate a paid service.

Design is part of the review. For UI-scoped work, add the optional Prestige Design Review: a purpose-led design brief plus review artifacts for hierarchy, responsive behavior, affordances, consistency, and declared design tokens. It makes design quality visible; it does not claim a conversion result, WCAG certification, or production readiness.

Reuse a proven decision without reusing stale context. Factory Continuity keeps a local, purpose-bound record of the evidence behind prior work. Graph Ops can replay only redacted, current, independently promoted metadata; it does not store private source, prompts, embeddings, or transcripts, and it cannot execute a repair.

Install

# No account, model key, or cloud connection is required for this local run.
pip install factoryline-code-factory
factory mvp "Build an approval tracker" --root .
factory studio --root .\my-mvp

If Code Factory helps you find a proof gap or makes an AI-assisted change easier to review, star Code Factory so other developers can find it. This optional link only opens the repository.

Choose the job in front of you

For the short product map, read the overview. For a two-minute first run, follow Start Here. For full command and contract reference, browse the documentation directory.

Use Code Factory with CodeRabbit or another AI reviewer

They solve different parts of the review problem. CodeRabbit can supply AI findings and suggestions; Code Factory makes declared local proof gaps, coverage, and the next review action explicit. Enable the opt-in GitHub Proof Review workflow to put one neutral, commit-bound FactoryLine Check and walkthrough beside existing CodeRabbit comments. It uses no CodeRabbit account, API, credential, or output as proof.

For agent-created pull requests, add a small human-approved factory.agent_plan.v1 envelope. Plan-to-Proof compares that plan with the exact diff and exposes Proof Debt: unresolved scope, declared-test, human-routing, and existing proof obligations that must be settled before a team makes its own merge decision.

That makes Code Factory a standalone proof layer for teams that do not use an AI reviewer, and a complementary evidence layer for teams that do. For agent-created pull requests, Code Factory does not replace human review, auto-approve a pull request, or merge code.

Use Code Factory with LangGraph

LangGraph teams can keep their own graph and checkpoint runtime, then use the LangGraph Assurance Bridge to compare recorded reference and resumed transitions. The free local adapter produces hash-only parity evidence and a reviewable incident capsule when a run diverges; it does not import LangGraph, invoke a graph, or claim production resilience. The optional GitHub Action puts the same Proof Card in a pull-request job summary.

For Codex, Claude Code, and Deep Agents, install the Code Factory LangGraph plugin to add the proof workflow and read-only local MCP facts to the coding-agent surface.

Use Code Factory with DeepSeek Harness

The optional DeepSeek Harness adapter starts the same local read-only MCP proof surface through Harness's official generic MCP client. It lets a Harness agent inspect Graph Ops, current proof gaps, and Earned Autonomy / Combine facts without sending source to a hosted endpoint or gaining permission to execute, repair, approve, release, deploy, sign, or use credentials.

Use it where you work

Code Factory keeps the same local, receipt-bound workflow across the command line, VS Code, and the JetBrains plugin. It also provides local stdio Cursor or OpenCode MCP without handing an AI client permission to publish, deploy, approve, sign, or access credentials.

The same local proof surface is discoverable in the Official MCP Registry as io.github.zrk222/code-factory; registry setup starts the public PyPI package over local stdio and never creates a hosted service or write authority.

FactoryLine's core local proof workflow remains free. The owner-approved future JetBrains Freemium plan starts January 1, 2027, subject to Marketplace and activation gates: $5.95 USD per named seat/month or $60 USD per named seat/year for optional Memory and Enterprise Assurance entitlements. It is not active today; no checkout, entitlement, or license enforcement exists. See the Marketplace control-room guide for the exact feature boundary and approval gates.

The matching GitHub Assurance Seat is also planned for January 1, 2027 at the same future price. It is for maintained, customer-managed proof operations (commit-bound review, Proof Debt, policy drift, governed exceptions, and evidence packets)—not source access or opaque AI-token resale. The source license and free core are unchanged. See the GitHub per-seat plan.

The proof boundary

Code Factory creates and inspects local artifacts. It does not silently call a model, discover credentials, publish, deploy, sign, approve, message, or grant a connector. The Gauntlet executes only caller-declared E2E pairs after a named, expiry-bound, one-run admission; all other Gauntlet paths are read-only. Its deterministic proof receipts bind supplied byte bindings, declared identities, and evidence; an external runner must separately prove runtime isolation and network policy. Token, cost, and productivity claims remain unknown until a bound measurement exists.

flowchart LR
  intent["Plain-language outcome"] --> mvp["Local MVP"]
  mvp --> evidence["Receipts and declared checks"]
  evidence --> review["Graph Ops / review packet"]
  review --> decision["One evidence-backed next action"]

Use Intake Grill to pin down intent before a mission, PRD Grill before code exists, the deterministic contradiction gate when requirements collide, Proof Review when a diff arrives, and the Verifier Plane when a worker claims it is finished. Use the supervised Gauntlet when a specific behavior needs to survive explicitly reviewed failure cases. The local MCP contract and generated Mermaid output map make the same proof context reusable by a client you choose.

Go deeper when you need it

• Read why I built Code Factory for the founder story behind catching passing tests that fail in real use.
• Start with PRD Grill, Proof Review, or Verifier Plane when the job calls for it.
• Browse Graph Ops, Gauntlet, Proof-Delta Loop, Graph Portfolio and Run Admission, Evidence Frontier, Factory Reality Check, proof reuse, and LangGraph Assurance, and savings boundaries for advanced evidence workflows.
• For UI work, read Prestige Design Review for the optional design-quality lane and its explicit review boundaries.
• Read The approval signal decays when AI-written code becomes routine for the design and limits of the habituation gate.
• See the release notes, CHANGELOG.md, release channels, and publication guide for versioned release detail.

License

MIT OR Apache-2.0.