Code Factory

6 mandatory audit lanes. 136 coded rejection conditions. One human-owned release decision.

Your code passed. But did it pass the right tests?

An AI agent—or a human developer—can write the code, write the tests, and set the rules used to approve its own work. Everything can turn green while the result still misses the request, leaks another tenant's data, breaks during a retry, damages a migration, or slows down in production.

Code Factory is an engineering audit and orchestration system: the independent review layer between “the build passed” and “a person should approve this.”

It seals the original intent before work begins, observes what changed, challenges the implementation and its tests, and connects every decision to inspectable evidence. If evidence is missing, contradictory, stale, or based on a weakened rule, the result does not quietly become a pass.

One review path, six questions

Those lanes contain 81 lane-specific and 55 cross-cutting coded rejection conditions. The source-bound inventory recomputes the total from the implementation; it is not a claim that every project executes 136 tests.

Built for the way you work

• Solo developers and vibe coders: get a second opinion before a plausible AI-generated change becomes your problem in production.
• Engineering teams: compare the request, code delta, independent checks, repair evidence, and remaining unknowns in one reviewable handoff.
• Enterprise teams: keep policy provenance, exceptions, approvals, tenant boundaries, and evidence traceable without giving the coding agent authority to redefine success.
• Connected agents: use the CLI, FactoryLine IDE surfaces, MCP, WebMCP, or A2A handoffs to follow the same bounded process and report the next action to a human.

Specialist modules join the same review when needed: Deep Defect Mesh consumes analyzer evidence, SaaS checks examine customer journeys, and AppForge organizes mobile build, design, privacy, signing, and store-submission evidence. AppForge does not replace the other audit lanes or promise store approval.

Choose your review path

pip install factoryline-code-factory
factory guide

factory guide is a read-only orientation: it shows the smallest suitable path without running tests or agents. When you are ready to produce evidence, follow the engineering review workflow. Its result shows what was checked, what failed, why it matters, what evidence supports the finding, and what must happen next. Code Factory does not promise perfect software. It makes the basis for approval visible and keeps the final decision human-owned.

Install the CLI, then follow the engineering review workflow for a full review:

pip install factoryline-code-factory

Want a small demonstration first? factory first-proof --root . challenges whether a test can actually reject its declared failure in a disposable sandbox. It writes a receipt and a privacy-safe Proof Card; it does not assess or change your project. First Proof is one entry point—not the scope of the full audit.

LLM-friendly product context: Canonical Product Card states the supported capabilities, boundaries, audiences, integration terms, and exact vocabulary that documentation assistants and agent tools may safely reuse. It is intentionally claim-bounded: local evidence is not a release, provider approval, remote execution, or a guarantee of correctness.

Pick the path that matches your work

Beyond hollow tests: Deep Defect Mesh evaluates signed analyzer-report contracts, flags missing negative controls, traces findings into Graph Ops, and compares repair outcomes. It coordinates supplied evidence; it does not execute the analyzers or guarantee that a clean report means safe code.

Choose your review path below. The current factory guide command still lists the existing onboarding paths, including the solo First Proof demo; it is not the full engineering-review workflow linked above.

• Individual developer or vibe coder: What did my change miss? Use the engineering review workflow to inspect intent, behavior, and evidence. Try factory first-proof --root . for a contained demonstration first.
• Engineering team: Did the agent build what we asked for? Start with factory oracle status --root .. Bind the original intent, observe the exact file delta, challenge the tests independently, and keep approval human-owned.
• Enterprise evaluator: Can we govern agent work without trusting the agent's story? Start with factory graph ops --root . --json. Inspect the source-to-decision chain, blockers, unknowns, and authority boundaries in a controlled pilot.

Choose the relevant audit scope. Specialized SaaS, mobile, multi-repository, and enterprise controls remain available in the advanced workflow guide only when their trigger applies. AppForge is an optional mobile-delivery capability; it surfaces avoidable gaps but cannot guarantee store approval.

For a release-bound service change, use the six-lane runtime assurance workflow. It coordinates stateful invariants, tenant isolation, fault recovery, consumer compatibility, database migration, and equivalent-load performance/resource checks under one signed plan. Every failed lane returns the consequence, evidence digest, exact replay, and next repair. A six-lane pass means ready for human review—not approved for release.

Senior engineering controls in 0.46.3

When a team needs stronger evidence than a self-reported green build, use the senior-engineering integration:

• verify an independently collected, candidate-bound execution attestation;
• measure a reviewed buggy/fixed defect corpus with case-level recall and precision; and
• route a dependency DAG through RUN, REUSE, SKIP, or BLOCK, then compare the incremental plan with a full baseline;
• reproduce a failure in a fresh, contract-bound process workspace, compare the original failure with a repair and negative controls, explain every reuse decision across policy/dependency/toolchain/environment fingerprints, and hand a reviewer a runnable, evidence-linked failure briefing.