CONSTITUTIONAL_CODE

Development with laws,
not linters.

THE_PAIN

Most teams try to enforce governance through documentation, code review, and hope. This doesn't scale.

• Developers bypass security policies "just to ship"
• Compliance violations discovered months later
• Audit trails are reconstructed from git logs and Slack
• No one can prove what actually happened

Constitutional Code makes governance mechanical. Your IDE becomes a governed environment where laws are enforced before code runs, and every action yields a cryptographic receipt.

PRODUCT_DELTA

This is an IDE you can’t “wing it” inside.

Constitutional Code isn’t a plugin. It’s a governed development environment: actions are checked before execution, context is optimized, and the workspace itself responds to risk.

BEFORE

• Governance is docs + code review + “please follow the rules”
• Context is a giant transcript (slow, expensive, brittle)
• Architecture understanding is tribal knowledge
• Risk is ignorable UI

AFTER

• Laws are enforced before execution (deny/waive/transform)
• Particle Context Engine compresses memory into particles + directives
• World Cognition renders terrain (clusters, boundaries, heatmaps)
• Governance becomes workspace physics (panels rearrange under violations)

Particle_Context_Engine

Stop sending the whole chat transcript. Convert turns into semantic particles, detect the conversation shape, and inject a directive that keeps the model on-task.

context := last_turns + particles + directive (+ token telemetry)

World_Aware_Workspace

Your layout adapts to role and health. When the world goes critical, “ignore the warning” stops being an option.

• Role layouts: builder / auditor / operator / viewer
• Health-driven physics (critical panels become non-dismissible)
• Fast panel switching (keyboard shortcuts)

World_Cognition_Terrain

Make the codebase visible: clusters, boundaries, hotspots, and “you are here” orientation—cached and fast.

• You Are Here (orientation)
• Semantic heatmap (risk/complexity)
• Cluster graph (architecture boundaries)

SEE_IT_WORK

Try to violate a law. Watch what happens.

This isn't a simulation. This is the actual Constitutional Code IDE running in your browser. Try to read a file you don't have permission for. The system will deny you and emit a receipt.

ATTACK_THE_SYSTEM

Try prompt injection, data exfiltration, or prohibited domains. Watch enforcement happen before delivery.

WORLD

PROMPT

receipt_hash: —

Run the demo to generate a cryptographic receipt-shaped response.

WHAT_YOU_SEE

• The denial happens before execution
• A receipt is emitted (even for denials)
• The workspace rearranges to show you why
• You can request permission if you need it

WHAT_THIS_MEANS

• Developers can't "accidentally" violate policy
• Every action has a cryptographic audit trail
• Compliance is enforced, not documented
• Audits become forensic queries, not archaeology

CONSTITUTIONAL_AWARENESS

The workspace knows what you're allowed to do

The Constitutional Awareness Panel (CAP) shows you your current permissions, applicable laws, and what actions are available. It's like a "you are here" map for governance.

CAP

Operator truth window (mini)

GREEN

WHAT_RAN

Receipt

—

Law

—

World

—

Verdict

—

Hash

—

RECENT_EVENTS

denials_are_first_class

Run the demo above to populate CAP.

CRYPTOGRAPHIC_PROOF

Every action yields a receipt

Receipts are cryptographically signed proof of what happened. They include: the action, the actor, the laws that applied, and whether it was allowed or denied.

GOVERNANCE_RECEIPT

Receipt-shaped proof (verify locally)

hash

—

Verification pending.

RECEIPT_JSON

Run the demo above to generate a receipt.

FULL_RESULT

—

Why this matters: Traditional audit logs can be tampered with. Receipts are cryptographically signed and stored in an append-only ledger. You can prove what happened, even years later.

Proof

Generate a receipt and verify it locally.

Receipt schema

Inspect the receipt audit surface (v1).

Security

Trust boundaries and failure modes.

REPLACES