Contract-first generation
Functional intent becomes explicit contracts before code, containers or runtime artifacts are generated.
Contract-first generation.
sigMAX
sigMAX turns functional intent into explicit contracts, generated architecture artifacts, and controlled runtime execution. FrontMark is a very rich markdown format used to produce sigMAX documentation
Hexagonal components
Domain boundaries stay visible, adapters remain replaceable, and microservices are used as deployment units.
WASM runtime control
Generated binaries run with constrained primitives, observable execution and reproducible packaging.
What sigMAX is
sigMAX is a contract-first engineering flow for modular applications. It helps describe what the system must do before implementation details spread across services, containers, configuration files, and runtime code.
The project connects four layers that are often treated separately:
- Intent: the functional goal, constraints, and expected behavior.
- Contracts: application, component, and binary descriptions that make the architecture inspectable.
- Generation: deterministic artifacts such as source code, service wiring, containers, and documentation.
- Runtime: a controlled execution boundary based on WebAssembly and observable services.
In practice, sigMAX is designed to make generated systems easier to reason about. The important decisions stay visible, the generated output can be compared with the expected state, and runtime behavior remains constrained enough to inspect.
Why it exists
Modern software can drift quickly: prompts change, generated files multiply, services acquire hidden assumptions, and documentation falls behind. sigMAX keeps a stable thread between the original intent, the contracts that describe it, the artifacts produced from it, and the runtime that executes it.
It is not meant to hide engineering work. It is meant to make the work traceable.
Claude for coding vs sigMAX
Claude is useful when the goal is to move fast inside source code: draft a function, explain a file, refactor a module, or explore an implementation idea. sigMAX goes further when the target is not just code, but a complete architecture that must stay explicit, reproducible, and executable.
| Need | Claude | sigMAX |
|---|---|---|
| Code fast | ✅ Snippets, refactors | ✅ Contract-generated code |
| Architecture | ⚠️ Prompt discipline | ✅ Decisions captured |
| Drift control | ⚠️ Context can fade | ✅ Expected vs generated |
| Deployment shape | ⚠️ Manual assembly | ✅ Containers and routes |
| Runtime control | ⚠️ Stops at code | ✅ WASM boundary |
| Auditability | ⚠️ Manual review | ✅ Inspectable artifacts |
Why sigMAX wins for serious generation
- The system starts from contracts, not from scattered prompts.
- Generated code is connected to architecture and runtime, not treated as an isolated snippet.
- Execution stays inside a controlled WebAssembly boundary.
- Documentation, generated artifacts, and runtime expectations stay part of the same chain.
- Drift becomes visible instead of quietly accumulating.
⚠️ Claude can help write code. sigMAX helps make generated software accountable.