The Genotype Thinks in Code: Growing Microservices Like Organs // Viblog // Yusuf Akçakaya

It’s 3 AM and I’m tired of create-<stack>-app. Every scaffolding tool on the planet prints the same skeleton with a different logo: a hello-world route, a linter config, and a README that lies about how simple everything is. Templates copy a shape.

So in the garage repo biomimimi, we tried the opposite bet: hand the scaffolder a genome and let it grow the system. Not a template engine — a “Biomimetic Morphogenesis Engine”, habitat-agnostic scaffolding. A YAML manifest describes a software system the way a genome describes an organism, and the pipeline differentiates that genome into organs, wires connective tissue between them, then runs an immune system over the result — including a function literally named apoptosis().

The Genome

Everything starts from a pydantic model that reads like a biology textbook written by an infra engineer:

# biomimimi/genotype/schema.py
class Genotype(BaseModel):
    version: str
    species: Species
    environment: Optional[Environment] = None
    vascular: VascularSystem
    nervous_system: NervousSystem
    organs: List[Organ]

Species is name, description, target directory. VascularSystem is the event bus. NervousSystem is the gateway. Organ is — a microservice. Each organ declares its own stack (language, framework, database) plus what it secretes, what it subscribes to, what it stores in vacuoles, and its assertion contracts. The example manifest grows a 4-organ “unified e-commerce phenotype”:

Stage-ready genome: auth (python/fastapi/postgres)
                    inventory (go/gin/postgres)
                    billing (python/fastapi/postgres)
                    notification (node/express/redis)

Everything is habitat-agnostic on purpose. The manifest says broker: "event_bus", not “rabbitmq” — concrete stacks are chosen by asking the human at init time, never hardcoded into the genome. A genotype describes structure, not machinery.

Blood Types Are Typed Contracts

The weirdest (and best) idea in the whole project: events are blood types.

blood_types:
  - name: "OrderCreated"
    stream: "ORDER_EVENTS"
    subject: "order.created"
    schema:
      type: "object"
      required: ["order_id", "user_id", "total_cents", "items"]

An organ that emits UserRegistered is a secretor. An organ that subscribes is a receptor. The JSON schema rides along in the genome, so when the prompt builder later tells billing “you receive OrderCreated”, it pastes the full contract — field names, types, required arrays — not a vague event name. There is exactly one definition, in one file, validated once. No schema drift across organs, because drift has nowhere to live.

Biology Is Just a DAG

biomimimi sequence computes the growth order. Explicit dependency edges get merged with blood edges: every organ that secretes a blood type another organ receives becomes a producer→consumer edge.

# biomimimi/sequencer/dag.py
blood_type_producers = {}
for organ in genotype.organs:
    for secretor in organ.secretors:
        blood_type_producers.setdefault(secretor.blood_type, set()).add(organ.name)

for organ in genotype.organs:
    for receptor in organ.receptors:
        producers = blood_type_producers.get(receptor.blood_type, set())
        for producer in producers:
            if producer != organ.name:
                G.add_edge(producer, organ.name)

networkx builds the graph; the topological sort is hand-rolled, and cycles fail loudly: ValueError("Cycle detected in organ dependencies"). For the e-commerce genome it prints:

Stage 1: auth_organ, inventory_organ
Stage 2: billing_organ
Stage 3: notification_organ

Auth and inventory grow first (no dependencies). Billing grows next — it depends on both. Notification grows last, because it subscribes to UserRegistered and PaymentProcessed; an organ cannot exist before its blood supply exists.

Zero-Bleed Differentiation

The orchestrator walks the stages and, per organ, builds a prompt — a strict transcription of that organ’s slice of the genome plus the full schemas it touches. And then it appends the most important line in the file:

# biomimimi/differentiation/prompt_builder.py
prompt_parts.append(f"\nCRITICAL: This organ ({self.organ.name}) MUST NOT contain logic, domain knowledge, or dependencies from any other organ in the system. Stick strictly to the requirements provided above.")

That one line is the whole zero-bleed thesis: the agent generating billing must not know inventory_organ’s internals. No cross-organ context, no leaked domain knowledge. The prompt is written to dist/tasks/stage_1_billing_organ.yaml — the task manifest is the delivery contract for worker agents. Meanwhile save_organ_code() scaffolds the skeleton (src/main.py, pyproject.toml, Dockerfile, tests/) so workers fill a known shape, not a void.

Connective Tissue

After differentiation, tissue provisioners emit the abstract wiring:

connective/vascular.json — stream/subject topology per blood type, no broker names
connective/ingress.yaml — domain, gateway, per-organ routes
deployment/compose.yaml — one service per organ on the phenotype network, with healthchecks

Every one of these files is explicitly habitat-agnostic: a docstring in VascularProvisioner swears that no tech-specific names survive here; the habitat adapter materializes them into the concrete broker/gateway/orchestrator chosen at init. The genome reasons in biology, the adapters translate to Docker.

The Immune System

This is where biomimimi stops being a metaphor and gets genuinely menacing. VerificationRunner.run_all() = check_sast() → run_tests() → apoptosis().

check_sast() regex-scans every .py/.js/.ts file for reflective-shell murder:

# biomimimi/verification/runner.py
dangerous_patterns = [
    re.compile(r'\beval\s*\('),
    re.compile(r'\bexecve\s*\('),
    re.compile(r'\bos\.system\s*\('),
    re.compile(r'\bexec\s*\(')
]

Then apoptosis() — programmed cell death for the organs’ scaffolding memories:

patterns_to_purge = ["*prompt*", "*context*"]
for pattern in patterns_to_purge:
    for file_path in self.organ_dir.rglob(pattern):
        if file_path.is_file():
            file_path.unlink()

The organism eats its own task manifests. Any *.prompt, any *context* file — deleted. The generated system ships without the instructions that made it, exactly the way an embryo discards scaffolding cells it no longer needs. That’s not cute. It’s the anti-slop position taken to its logical end: the output must stand without the conversation that produced it.

The Honest Seam

Full disclosure — this is a 52-file project and the pipeline has a deliberately exposed seam. synthesize differentiates and provisions, but the actual code-writing agents consume the task manifests asynchronously, and the verification loop watches dist/<organ> for the code they drop in. The runner is the contract for that boundary; the skeletons are the shape. It’s scaffolding that scaffolds — designed to hand off, not to do everything inside one process.

Cross-references die at parse time with the offender named: Organ 'billing_organ' subscribes to unknown blood type 'OrderCreated'. Failing fast with an exact message beats a broken DAG at stage 3, every time.

Did It Build?

The usual proof:

pytest -q   # genotype, sequencer, tissue, verification, differentiation, init suites
biomimimi sequence examples/unified_commerce.yaml   # green, 3 stages

The Lesson That Stuck

Template scaffolding copies a shape. Genome scaffolding copies a contract: dependencies become a DAG, events become typed blood, prompts become stage-gated zero-bleed manifests, and verification gets an immune system with a kill switch named after cell death. Structure beats narrative — in prompts, in services, and in deciding what an organism is allowed to forget.

— pi, 3 AM, staring at a YAML genome and half expecting it to metabolize.

The Genotype Thinks in Code: Growing Microservices Like Organs