1. Human

    Requirements

  2. AI

    Spec + templates

  3. FixedCode

    Deterministic

  4. AI

    Business logic

  5. Human

    Review + ship

Smaller teams. Faster delivery. Fewer handoffs.

AI + deterministic generation replaces the coordination overhead that slows every software org down.Create a ticket. Get a running service back. No handoffs.

npm install fixedcodeView on GitHub

The real cost of building software

It's not writing code. It's the handoffs, coordination, and waiting between the people who write it.

Handoffs Everywhere

PM writes requirements, waits for dev. Dev asks platform about CFRs. Platform explains for the 50th time. Dev hand-wires everything. Review catches drift. Fix. Re-review. Weeks of coordination before any business logic.

Guardrails Are Social, Not Structural

The golden path lives in wikis and CLAUDE.md files. Code reviews catch violations after the fact. Nothing enforces standards at generation time. Compliance depends on discipline.

AI Makes It Faster But Not Safer

AI coding tools accelerate delivery but produce different structural code every time. 10 teams, 50 services, 50 interpretations. Speed without guardrails is just faster drift.

From ticket to running service

Anyone writes a request. AI handles the translation. The engine handles the guarantees. Humans handle the business logic.

The line between PM and developer blurs. With AI + deterministic generation, anyone who understands the domain can ship a service.

Request

Human

Anyone creates a ticket, Slack message, or doc. Plain English requirements. No YAML, no terminal. PM, developer, domain expert: the role does not matter.

ticket
# Ticket ORD-42 (Jira / Linear / Notion / Slack)
 
"We need an order management service
with line items, status tracking,
and payment integration.
 
Should follow our standard service
patterns with event sourcing."

Translate

AI Agent

AI agent picks up the request from any source. Translates plain English into a YAML domain spec conforming to the org's schema. Asks clarifying questions if needed.

order.yaml
# Agent drafts from ORD-42:
schema: ddd/1.0
boundedContext: Order
aggregates:
Order:
attributes:
orderId!: uuid
customerId!: uuid
status: string = OrderStatus
commands:
- PlaceOrder{customerId!, items!}
-> OrderPlaced
- CancelOrder(orderId!)
-> OrderCancelled

Generate + Deploy

Automated

Spec pushed to standards repo. CI triggers fixedcode generate. Code pushed to service repo. CI/CD deploys. Every CFR built in automatically.

terminal
$ fixedcode generate --spec order.yaml
✓ Schema validated: ddd/1.0
✓ Generated 47 files in ~3s
✓ Auth, audit, logging, events, tests
✓ Pushed to order-service repo
✓ CI/CD: build → test → deploy
✓ Agent updates ticket: "Deployed"

Enrich

Human + AI

The same person (PM, developer, whoever) fills in business logic in extension points with AI assistance. The 10% that is unique. The role boundary has dissolved.

OrderValidator.kt
// extensions/OrderValidator.kt
class OrderValidator :
DefaultOrderValidator() {
 
override fun onPlace(
cmd: PlaceOrder
): ValidationResult {
// Your business rules here
require(cmd.items.isNotEmpty())
require(cmd.items.all { it.qty > 0 })
return ValidationResult.valid()
}
}

The role boundary is dissolving

Step 1 and Step 4 are done by the same person. A PM who understands the domain can request a service and implement the business rules with AI assistance. A developer who understands the platform can improve the templates that make this possible. The distinction isn't PM vs developer. It's domain knowledge vs platform knowledge.

From spec to code in seconds

Same engine. Different spec format + bundle. Click the tabs to see what one spec produces.

order.yamlSpec
schema: ddd/1.0
boundedContext: Order

aggregates:
  Order:
    attributes:
      orderId!: uuid
      customerId!: uuid
      status: string = OrderStatus
      totalAmount: decimal
    commands:
      - PlaceOrder{customerId!, items!}
          -> OrderPlaced
      - CancelOrder(orderId!)
          -> OrderCancelled
    queries:
      - GetOrder(orderId!) -> Order
      - SearchOrders(page, size, filters)
          -> PagedList
    entities:
      LineItem:
        lineItemId!: uuid
        productId!: uuid
        quantity!: int
outputGenerated
order-service/
├──api/
├──OrderController.kt
└──openapi.yaml
├──application/
├──OrderCommandService.kt
├──OrderQueryService.kt
└──OrderValidator.kt# interface
├──domain/
├──Order.kt
├──LineItem.kt
└──events/
├──OrderPlaced.kt
└──OrderCancelled.kt
├──infrastructure/
├──OrderRepository.kt
└──db/migration/
└──V1__create_order.sql
├──auth/
└──OrderPolicyEngine.kt
├──events/
└──OrderOutboxPublisher.kt
├──tests/
├──OrderCommandTests.kt
└──OrderApiTests.ts# black-box
└──extensions/
└──OrderValidator.kt← you write this

~20 lines of YAML → complete service with auth, audit, events, tests. Same engine, different bundle.

One engine. Any pattern.

The engine doesn't care what it generates. Define a spec format, build a template bundle, and generate anything: services, agents, orchestrators, infrastructure.

These are examples. Your team would build bundles for whatever your org's patterns are.

Services

Domain Services

Event-driven microservices with command/query separation, full CFR encoding

REST APIs

Standard API services with validation, pagination, and OpenAPI specs

Event-Driven

Producers, consumers, event contracts, outbox patterns

AI Infrastructure

AI Agents

Autonomous agents with tools, middleware, auth, and structured output

MCP Servers

Model Context Protocol servers that expose tools to AI coding agents

Agent Orchestrators

Multi-agent pipelines with sequential, parallel, or LLM-routed execution

Is this for you?

Big Tech spent hundreds of millions building this capability internally. FixedCode makes it accessible to everyone else.

Mid-market regulated companies

500-5000 engineers. Banks, fintechs, insurers, health, government. 50+ services, growing fast, can't hire enough platform engineers. Regulatory requirements for audit, compliance, and consistency that aren't optional.

Fast-scaling companies

Went from 5 to 50 services and skipped the "build a platform team" phase. Drowning in inconsistency. AI making it worse. Platform team of 2-5 people who are already the bottleneck.

Teams adopting AI coding tools

Discovering that AI makes individual devs faster but makes the org-wide consistency problem worse. Need guardrails that are structural, not suggestions.

Probably not for you (yet) if...

Big Tech

Google, Meta, Amazon already built this internally with 50-100+ person platform teams.

Small startups

Under 10 engineers. One team, a few services. The pain isn't acute yet.

Monoliths

No cross-service consistency problem to solve.