Ship code from specifications
Stop prompting for the next token. Write a declarative .aexol specification and ship a whole feature — TypeScript, Python, Rust, Go, GraphQL, and Prisma — in one validated, version-controlled pass. The spec is the source of truth, not a chat transcript.
WHAT IT IS
A specification language that ships code, not suggestions
Shipping code from specifications means you describe an application in a human-readable, declarative format and a pipeline turns that description into production-ready code. The description lives in a .aexol file that declares your types, workflows, roles, and agents. It is the contract every artifact is generated from.
Aexol is the AI-native specification language for this. Its parser builds an abstract syntax tree from your spec, validates type references and workflow transitions, and an inference pipeline generates GraphQL schemas, Prisma models, API routes, webhooks, cron jobs, and tests. The result is reviewable, version-controlled, and reproducible across runs.
HOW IT WORKS
From spec to shipped code in three steps
Write the specification
Declare types, workflows, roles, and agents in a .aexol file. Or describe your app in chat and let Aexol draft the spec for you to edit.
Parse and validate
The parser builds an AST, resolves type references, and reports unknown types and invalid transitions. Zero errors means the spec is ready to generate from.
Ship the artifacts
The inference pipeline emits GraphQL schemas, Prisma models, API routes, webhooks, cron jobs, and tests — validated against the spec, ready to review in your pull request.
WHY IT MATTERS
Five advantages of shipping from a spec
The spec is the source of truth
One .aexol file describes types, workflows, roles, and agents. It is declarative, reviewable, and diffable — you never regenerate from a lost chat transcript.
Zero type errors by construction
The parser resolves every type reference and validates fields and transitions before generation. When the spec passes, the generated code matches the declared types by construction.
One spec, many targets
Generate TypeScript, Python, Rust, Go, GraphQL schemas, and Prisma models from a single specification. Maintain one source of truth across every platform you ship to.
Predictable generation cost
Because you validate the spec and preview artifacts before the agent runs, you spend tokens on generation that is already known to be correct — not on retry loops.
Reproducible and version-controlled
The same spec produces the same artifacts. Review the diff in your pull request the same way you review any other code change — generation is a build step, not a chat.
THE FIVE PILLARS
What makes shipping code from specifications possible
Aexol Studio — predict output before you generate
Studio is the visual editor for specifications. It renders a graph of your types and workflows, runs live AST validation, and lets you select models and refine prompts before the inference pipeline runs. You preview what will be generated, adjust parameters, and only then ship code.
Open StudioInference pipeline — zero type errors on generation
The inference pipeline parses your .aexol spec, resolves types, and emits GraphQL schemas, Prisma models, API routes, webhooks, cron jobs, and tests. Validation runs before generation, so unknown types and missing fields are caught at the spec layer — not at the compiler.
See the agentOutput forecast — cost and scope before you run
Because the spec declares every type and workflow, you can forecast what will be generated before spending tokens. Studio shows the graph of artifacts and the selected model, so generation cost is predictable rather than a surprise on the invoice.
Spec-driven compliance — reviewable, auditable, versioned
A specification is a contract you can review and audit. Roles, permissions, and workflows are declared explicitly, so compliance reviewers read the spec instead of reconstructing intent from generated code. Every change is a diff in version control.
Spectral — the agent harness that runs it
Spectral is the agent harness that parses the spec, plans the generation, and writes the artifacts. It supports autonomous multi-step execution, provider routing to any LLM, and credit-based billing through Aexol.
GO DEEPER
Three ways to ship code from specifications
Spec-driven development
How a declarative spec replaces the prompt as the unit of work, and why the diff is the review.
ReadAI output prediction
Preview what will be generated before you spend tokens, and keep generation cost predictable.
ReadPM/BA + Studio
Define requirements visually, validate the spec, and hand engineering a reviewable contract.
ReadCOMPARISONS
Aexol vs. the tools you already know
FAQ
Questions about shipping code from specifications
What does "ship code from specifications" mean?
It means you write a declarative .aexol specification that describes your application — types, workflows, roles, agents — and a parser plus AI inference pipeline generate the implementation. Instead of prompting a chat for each edit, you ship the whole feature from one versioned spec file that is the source of truth.
How is spec-driven different from prompt-driven code generation?
Prompt-driven tools like Copilot autocomplete the next token or run a conversational agent. Spec-driven generation parses your .aexol file into an AST, resolves types, validates references, and emits GraphQL schemas, Prisma models, API routes, webhooks, cron jobs, and tests in a single pass. The spec is reviewable and diffable, so the output is reproducible across runs.
Which languages can Aexol generate from one specification?
From a single .aexol spec you can generate TypeScript, Python, Rust, and Go application code, plus GraphQL schemas and Prisma models. You maintain one specification while targeting multiple platforms, and each artifact is validated against the spec before it is written.
Does spec-driven generation produce zero type errors?
The parser resolves every type reference and reports unknown types, missing fields, and invalid workflow transitions before any code is generated. When the spec validates with zero errors, the generated code matches the declared types by construction. You still review the output, but the class of type-mismatch bugs caught by the compiler is eliminated at the spec layer.
Can I use Aexol Studio to predict output before generating code?
Yes. Aexol Studio renders a graph visualization of your spec, runs live AST validation, and lets you select models and refine prompts before the inference pipeline runs. You preview what will be generated, adjust parameters, and only then ship code — which is how Aexol keeps generation cost predictable.
Is Aexol free and open source?
No. Aexol is not open source — the repository is private. It's built on credit-based billing: generation is metered and billed through Stripe. You can still route inference to the LLM provider of your choice.
Who benefits most from shipping code from specifications?
Product managers and business analysts use the Studio to define requirements visually and get a previewable spec. Senior engineers treat the spec as a reviewable contract and generate the boilerplate. Teams that want reproducible, version-controlled generation across TypeScript, Python, Rust, and Go from one source of truth get the most leverage.
How do I get started shipping code from specifications?
Install Aexol, write your first .aexol specification (or describe your app in the chat and let Aexol draft the spec), validate it in the Studio, then run the inference pipeline. You can start free or book a demo to see the full spec-to-code flow on your use case.
Drafted with Aexol Studio + Spectral
Start with a spec, not a prompt
Generate full implementations from .aexol specifications. Credit-based billing, visual Studio, and zero type errors by construction.