All chapters
  1. Start hereA software factory, from first principles
  2. Primitive · 1A factory, before AI: input, transformation, check, output
  3. Primitive · 2From repetition to a pattern: what stays, what varies, what to leave alone
  4. Primitive · 3The specification as an executable contract
  5. Primitive · 4Build the smallest factory: four stations, two specs, one manifest
  6. Primitive · 5Assembly stations: typed contracts, owners and failure handling
  7. Primitive · 6AI enters the factory: what a model adds, and what stays deterministic
  8. WatchAlgo · 7The WatchAlgo production story: what the repository shows
  9. WatchAlgo · 8A problem as a production unit: the files one unit must contain
  10. WatchAlgo · 9Station by station: description, solution, implementations, visualization
  11. WatchAlgo · 10The visualizer factory: from algorithm state to renderable steps
  12. WatchAlgo · 11Three flavors and three languages: two different contracts
  13. WatchAlgo · 12Looping over a large backlog: scheduling, limits and a failed-case queue
  14. WatchAlgo · 13Long-running agent execution: context, checkpoints and token limits
  15. WatchAlgo · 14Evidence of correctness: tests the producer cannot talk its way past
  16. WatchAlgo · 15The factory learning loop: defects change the pattern, not only the unit
  17. Enterprise · 16Classify the enterprise demand before choosing a pattern
  18. Enterprise · 17Reference enterprise patterns and their variation points
  19. Enterprise · 18Platform foundations: golden paths, templates, registries and catalogs
  20. Enterprise · 19Pattern versus configuration versus business logic
  21. Enterprise · 20Insurance factory, part 1: building the intake contract
  22. Enterprise · 21Insurance factory, part 2: building the underwriting workflow
  23. Enterprise · 22Insurance factory, part 3: trust and observability built in
  24. Enterprise · 23Data and integration engineering: contracts that survive change
  25. Enterprise · 24The CI/CD and deployment factory: from pull request to production
  26. Enterprise · 25Enterprise governance: owners, approved patterns and provenance
  27. Enterprise · 26Scaling safely: many teams, many agents, one set of boundaries
  28. Operations · 27Factory quality engineering: measuring accepted output, not activity
  29. Operations · 28Failure and recovery scenarios: what breaks a factory, and what restores it
  30. Operations · 29The landscape: which tool for which job, read from its own documentation
  31. Operations · 30Design an enterprise software factory: the blueprint and the rollout
  32. ReferenceSources and verification
  33. ReferenceGlossary
  34. AboutAbout this site
Enterprise · 16

Classify the enterprise demand before choosing a pattern

Users and roles, outcomes, data, upstream and downstream services, security, compliance, deployment targets, service levels and maintainers. Discovery questions, and unknowns kept visible.

You will classify
An enterprise request on nine dimensions, from users and data to service levels and the people who maintain it.
You will keep
An unknowns register in which every open question has an owner and names the station it blocks.
You will see
Where the critical path is not code generation: integration, regulation, legacy behavior, security approval, undecided requirements.

The request reaches the platform team on a Monday, from the insurer's submissions group: "We need an intake thing for broker emails. Make it smart. Ship it this week."

A factory exists that builds intake services. It has a pattern, PAT-INTAKE-API 2.1.0, with an eight-step skeleton: parse the request, authenticate, check the role, validate the body, keep an idempotency key, write an audit record, emit events, carry a trace id. A team could fill in a spec by Tuesday and have generated code by Wednesday. And then the questions would start arriving, one at a time, each one after the code that depended on it was already written. Which identity provider do brokers sign in with? Is a broker's email address personal data that logs must mask? Who turns an email into a structured submission? May the underwriting agent record a decision, or only a recommendation? Who is on call when the service fails on a Saturday?

None of those questions is about code. Each of them changes the code. The factory can generate an endpoint quickly; it cannot generate the answers.

The learner's question: before a factory chooses a pattern and starts a single station, what must it know about an enterprise request, how does it find out, and what does it do with what nobody knows yet?

The demand is not the spec#

Plain English. Demand is what the business asks for, in its own words. A spec is what the factory can build from. Turning one into the other is work done by people, and the factory should refuse to start until it is done.

Demand intake is the step that receives a request, classifies it on a fixed set of dimensions, records what is still unknown, assigns a risk tier and only then picks a pattern. A tiny example: the one-line request above, classified, yields roles (broker, underwriter, auditor, underwriting agent), a data class (personal data: the broker's email), a risk tier (high: outside users, regulated decision support) and a pattern (PAT-INTAKE-API). The operational consequence is that the factory's first station receives a spec with every gap visible, instead of a spec whose gaps a station worker will fill by guessing. The trade-off is time before any code: hours or days of people's attention that feel slower than generating something.

This page sits one step before The specification as an executable contract. That chapter validates a spec that exists; it asks whether the spec is complete and consistent. This page asks the earlier question: what has to be true of the demand before a spec can be written at all, and which parts of it are not the factory's to decide.

Before AI. Enterprise architecture teams have long run this as a discovery phase or an architecture intake form: business context, stakeholders, data classification, integrations, non-functional requirements, a risk rating, sign-off. The factory changes one thing. A human team that skips discovery discovers the answers late and slowly; a factory that skips it discovers them late and fast, after it has generated a large amount of code built on guesses.

Nine dimensions of an enterprise request#

Here is the classification, worked for the insurer's request. The middle column says what Example C's product spec, SPEC-INTAKE-001 (examples/c-insurance-service/product_spec.json), answers. The right column is what the spec does not answer. Everything here is synthetic: the insurer, its people and its rules are invented for teaching, and the factory builds the service; it never decides an underwriting case.

DimensionThe questionWhat SPEC-INTAKE-001 answersStill open in the spec
Users and rolesWho uses it, and what may each role do?4 roles: broker, underwriter, auditor, underwriting agent; only underwriter records a decisionhow outside brokers sign in
Business outcomesWhich result tells us it works?product broker-submission-intake; workflow received to decidedno outcome measure (for example, time from email to recommendation)
Data sources and classesWhich data comes in, and how sensitive is it?submission schema v2, 12 typed fields; broker_email marked piiretention period; the scenario's full 63-field submission
Upstream servicesWhat feeds it?a JSON submission bodywho turns the broker's email into that JSON
Downstream servicesWho consumes its output?6 versioned event typeswhich systems consume each event
SecurityHow is identity proven, and who may do what?roles per route; demo tokens; logs mask personal datathe real identity provider; security review
ComplianceWhich rules govern the data and the decision?R-HUMAN-01: an authorized underwriter decideswhich regulations apply; who approves the recommendation reasons
Deployment targetsWhere does it run?environments dev, staging, production; canary 5% for 60 minutes (documentation only)the platform it deploys to
Service levels and maintainersHow good must it be, and who keeps it running?provider timeout 2,000 ms, at most 3 attempts; rollback conditionsno service-level objective; no named maintainer

Read the right column as a list of work the factory cannot do. Several items in it are decisions by people outside engineering: a compliance officer, a security architect, the owner of the email channel. The spec is excellent at what it covers; it does not cover the organization.

A service-level objective (SLO) is a target for how well a service must behave, stated as a measurable level over a period: for example, 99.5% of submission requests answered without a server error over 30 days (an illustrative number, not from the example). It is different from the spec's rollback conditions, which say when to undo a release; an SLO says what "working" means every day afterwards, and it decides how much testing, redundancy and on-call the factory must install. A maintainer is the named team or role that owns a product after it ships: it answers pages, approves changes and receives the defects the factory's learning loop records. A product without a maintainer is an orphan the day it launches.

The smallest primitive: an unknowns register#

Discovery questions are the questions a team asks the people who own the demand, one or more per dimension, chosen to surface decisions rather than preferences. "Which identity provider do brokers sign in with?" is a discovery question; "Should it be secure?" is not, because every answer is yes.

An unknowns register is the list of discovery questions that have no answer yet, each with an owner who will answer it and the station or release step it blocks. The register turns "we'll figure it out" into a gate. Teaching reconstruction: the entries and owners below are this site's own; owners are roles, not people. The script was written for this page and run here.

REGISTER = [
    {"id": "U-01", "question": "Which identity provider do brokers sign in with?",
     "dimension": "security", "owner": "security architect", "blocks": "S1-validate-spec", "answer": None},
    {"id": "U-02", "question": "Who turns a broker email into a submission, and who checks the draft?",
     "dimension": "upstream", "owner": "submissions product owner", "blocks": "S1-validate-spec", "answer": None},
    {"id": "U-03", "question": "How long are submissions and audit records kept?",
     "dimension": "compliance", "owner": "compliance officer", "blocks": "release", "answer": None},
    {"id": "U-04", "question": "Who is on call for the service after launch?",
     "dimension": "maintainers", "owner": "engineering manager", "blocks": "release", "answer": None},
    {"id": "U-05", "question": "Which fields are personal data?",
     "dimension": "data", "owner": "data protection lead", "blocks": "S1-validate-spec",
     "answer": "broker_email (observability.pii_fields)"},
]


def can_start(register, station):
    """A station may start only when no open unknown blocks it."""
    open_blockers = [u for u in register if u["answer"] is None and u["blocks"] == station]
    return (not open_blockers), open_blockers


for station in ("S1-validate-spec", "release"):
    ok, blockers = can_start(REGISTER, station)
    print(f"{station}: {'may start' if ok else 'blocked'}")
    for u in blockers:
        print(f"  {u['id']} [{u['dimension']}] {u['question']} -> {u['owner']}")
answered = [u["id"] for u in REGISTER if u["answer"]]
print(f"answered: {answered}; open: {len(REGISTER) - len(answered)}")
S1-validate-spec: blocked
  U-01 [security] Which identity provider do brokers sign in with? -> security architect
  U-02 [upstream] Who turns a broker email into a submission, and who checks the draft? -> submissions product owner
release: blocked
  U-03 [compliance] How long are submissions and audit records kept? -> compliance officer
  U-04 [maintainers] Who is on call for the service after launch? -> engineering manager
answered: ['U-05']; open: 4

Two design choices carry the idea. Every unknown names what it blocks: some block the first station, because the spec cannot be written honestly without them; others block only the release, so the factory may build while a compliance officer decides retention. And every unknown has an owner who is a role in the business, not the factory. The factory's job is to keep the register visible and to refuse to pass a gate while a blocker is open. It is not the factory's job, and never a station worker's, to answer the question.

Diagram: From a request to station 1 · classify, register, tier, pattern

Three lanes, left to right. In the classify lane, the one-line request is sorted on nine dimensions. Answered dimensions flow into the product spec; unanswered ones become entries in the unknowns register in the second lane, each routed to an owner outside the factory. The classification sets a risk tier, and tier plus dimensions choose a pattern. In the factory lane, station 1 receives the spec with the register beside it: a blocker aimed at station 1 stops the run before any agent starts, and a blocker aimed at release holds only the promotion.

  1. Classify the demand
    1. one-line request: The business asks in its own words; nothing here is buildable yet.
    2. nine dimensions: Each dimension gets discovery questions answered by the people who own it.
    3. risk tier: The highest signal sets the tier, which sets gates and approvals.
  2. People outside the factory
    1. unknowns register: Open questions become entries with an owning role and a blocked station.
    2. owners answer: Answers come from the roles that own them, never from a station worker.
  3. Factory
    1. pick a pattern: Tier and dimensions choose one of the reference patterns.
    2. S1 validates spec + reads register: Station 1 refuses missing extension points, a decision route opened to an agent, and open blockers.

Read the diagram left to right. The request is classified on the nine dimensions. Answered dimensions flow into the product spec; unanswered ones become entries in the unknowns register, each routed to an owner outside the factory. The classification sets a risk tier, and the tier and the dimensions together pick a pattern. Only then does station 1 receive the spec, with the register beside it: a blocker that targets station 1 stops the run before any agent starts.

What the factory checks, and what it cannot#

The factory's own first station is strict about the gaps it can see. Example C's factory.py : s1_validate_spec is quoted verbatim:

def s1_validate_spec(pattern: dict, spec: dict) -> list[str]:
    """Unknowns become errors, not guesses: selecting a pattern does not excuse a missing behavior."""
    problems = []
    want = {"id": pattern["pattern_id"], "version": pattern["version"]}
    if spec.get("pattern") != want:
        problems.append(f"spec asks for pattern {spec.get('pattern')}, factory has {want}")
    for ep in pattern["extension_points"]:
        if ep not in spec:
            problems.append(f"extension point not filled: {ep}")
    for r in spec.get("routes", []):
        if r["id"] not in pattern["skeleton_handlers"]:
            problems.append(f"route {r['id']} has no handler in the pattern skeleton")
        if r.get("decision_route") and sorted(r["roles"]) != sorted(pattern["constraints"]["human_decision_roles"]):
            problems.append(f"route {r['id']} lets {r['roles']} decide; pattern allows only "
                            f"{pattern['constraints']['human_decision_roles']}")
    for name in spec.get("events", {}):
        if not name.rsplit(".", 1)[-1].startswith("v"):
            problems.append(f"event {name} does not carry a version")
    return problems

A scratch run on a copy of the example: the real spec returns no problems. A copy with two extension points removed (external_systems, rollout) and the decision route opened to the underwriting agent, the kind of spec a team writes in a hurry, returns:

real spec: []
   extension point not filled: external_systems
   extension point not filled: rollout
   route record_decision lets ['underwriter', 'underwriting-agent'] decide; pattern allows only ['underwriter']

The third line is the one that matters for this domain. The pattern holds the constraint that only the underwriter role records a decision, and no product spec can override it. The model recommends; a person decides, and here the factory enforces that before a line of the service exists.

Now notice what the same function cannot see. It checks that external_systems is present; it cannot check that the roof-data provider's real contract matches it. It checks that roles are declared; it cannot check that brokers have accounts in any identity provider. It knows nothing about retention, regulators, maintainers or service levels, because the pattern does not declare them as extension points. The specmeter lab rates the same spec 95 out of 100 and passes it, with one missing part: the spec lists no unknowns. A spec can be complete in every field a validator knows and still be built on a demand nobody classified.

Common confusion. A high spec score is not a classified demand. The spec gate measures the parts a pattern declares. Demand classification covers the parts no pattern declares: the organization's decisions, approvals and people. Run both; neither replaces the other.

Where the critical path is not code generation#

The site's anti-claim applies here with full force: no factory turns an enterprise request into a production service in days by generating faster, because for most enterprise requests generation is not what takes the time. For the insurer's intake service, these are the items that decide when it can go live. Teaching reconstruction: the items are typical of such a service; no durations are claimed.

Diagram: Where the time goes · the factory lane is short

Rows are the factory and the organization around it; columns are before the build, the build, and before release. The factory lane holds four stations that run in minutes in Example C. The organization lane holds the decisions that run on other teams' calendars: what a complete submission is, the email channel, the identity provider, data handling and retention, legacy behavior, the on-call team. Arrows from the organization lane are blocking unknowns. The release waits on both lanes. No durations are claimed; this is a teaching reconstruction.

  1. Organization
    1. agree what a complete submission is: An undecided requirement owned by the business.
    2. connect email channel + identity provider: Other systems' contracts and approvals the factory cannot generate.
    3. data handling review, legacy behavior, on-call: Release blockers: retention, recorded legacy behavior, a named maintainer and an SLO.
  2. Factory
    1. S1 validate spec: Checks extension points, routes, decision roles and event versions.
    2. S2 contracts, S3 service, S4 manifest: The generation work: short and repeatable.
    3. gates + approvals: Promotion waits on the gates and on every release blocker in the register.

The swimlane shows two lanes over time. The factory lane is short: validate the spec, generate contracts, assemble the service, write the manifest. The organization lane is long and runs on other people's calendars: agree what a complete submission is, connect the email channel, approve the identity provider, review data handling, confirm legacy behavior, name the on-call team. Arrows from the organization lane into the factory lane are the blocking unknowns; the release gate waits on both.

ItemWhy it dominatesWhose decision
Integrationthe email channel, the roof-data provider and every downstream event consumer each have their own contract, owner and release cycleeach system's owning team
Regulationwhich rules govern personal data and decision support, and what records the regulator expectscompliance and legal
Legacy behavioran existing system that receives submissions today has behavior nobody wrote down, and consumers depend on itthe legacy system's owners, by recording what it does
Security approvalsidentity provider, threat model, penetration test, access reviewthe security team, on its own schedule
Undecided requirementswhat makes a submission complete: the scenario's submission has 63 fields, the example carries 11 plus onethe business owner of submissions

A factory shortens the build. It can also shorten some of these items: a contract generated from the spec gives the security reviewer something precise to review, and an unknowns register stops a question from being discovered in week five. It cannot make another team's approval arrive sooner. A pilot that measures "time to generated code" will report a dramatic number; a pilot that measures "time from request to production" will report the honest one, and the difference is this table. Factory quality engineering defines lead time with that start point.

To plan such a change before the first meeting with the people who own it, Ask to Release covers the brief and the questions to bring.

Risk tiers: how much machinery the demand earns#

A risk tier is a label, assigned at demand intake, that sets how many gates and approvals a product needs, from the harm a defect could cause. A tiny example: an internal report over public data is low; the insurer's intake service, with outside users, personal data and a decision that affects a business's insurance, is high. The consequence is that the tier, not the team's enthusiasm, decides whether a canary, a security sign-off and a person deciding every case are required. The trade-off is that a tier set too low ships risk, and a tier set too high buries a low-risk tool under approvals until teams route around the factory.

This site's recommendation, as the wizard lab encodes it (examples/labcore/b_wizard.py : plan, a teaching reconstruction): low risk gets unit tests, a security scan and a human approval gate before promotion, plus two sign-offs: the spec owner signs the spec, and a person with merge rights reviews the change. Medium adds a release approver and a canary with automatic rollback. High adds a security reviewer and the business domain owner; regulated data adds a compliance reviewer; and any product with a model in it at medium or high risk carries a run-time rule that a person decides every case. For the insurer's choices (document intake, outside partners, regulated personal data, REST and events, a document store, a model provider, high risk, a container platform) a scratch run of plan returned nine gates, seven approvals and seven unknowns, quoted in the lab table below.

Three signals set the tier, in this order: who is harmed if the product is wrong, and how many of them; whether the harm can be undone (a wrong log line can, a recorded decision sent to a business cannot); and whether the data or the decision is regulated. When signals disagree, the highest wins, and lowering a tier is an exception with a named approver, never a default.

In a coding agent. A coding agent running as a station worker receives a work item drawn from the spec, never the raw demand. If the item touches an open unknown, the correct output is a question routed to the register's owner, and the factory's own checks, not the agent's account, decide whether the item advances. The controls around the agent's run are Harness Engineering.
What this is not. This page classifies a demand for a factory. Writing and validating the resulting spec is The specification as an executable contract; planning a change and briefing its owners is Ask to Release; choosing a pattern from the eight reference shapes is the next chapter. Authorization design is Auth Engineering.

Try it#

The first lab rates Example C's real spec, SPEC-INTAKE-001, on nine parts. Toggle parts between clear, vague and missing and watch the gate, the score and the questions sent back to the author. "No agent starts until this passes."

PresetProfileClear · vague · missingScoreGateQuestions (blocking)
intakeintake service8 · 0 · 195pass2 (0), both about unknowns
vagueintake service0 · 2 · 79blocked by 8 must-haves16 (14)

The two questions the intake preset sends back are the register's own: "What do we not know yet, and who will answer it by when?" and "Which assumption would change the design if it is wrong?" The score is this site's teaching measure, not a standard.

The second lab classifies a demand the way this page does: app type, users, data class, integrations, risk tier and deployment target produce stations, gates, approvals, a pattern id and a spec skeleton whose unknowns are questions. It never deploys anything.

The table was written for this page from a scratch run of b_wizard.plan (docs/LABS.md has no plain table for this lab yet). The catalog is the lab's own; only the document-intake row maps to Example C's real pattern and its four real stations.

ChoicesPatternStationsGatesApprovalsUnknowns
default: CRUD portal, internal staff, internal data, own database, low risk, containerPAT-CRUD-PORTAL 1.2.0 (synthetic)7, incl. migrations6: unit tests, contract check, migration dry run, security scan, human approval, promote2: spec owner signs; merge review2: owner after ship; done as testable criteria
the insurer: document intake, partners, regulated data, REST, events, document store, model provider, high risk, containerPAT-INTAKE-API 2.1.0 (from Example C)7: Example C's four plus retrieval index, event schemas, golden-case evals9, adding event compatibility, masking check, evals, canary with rollback7, incl. security, domain owner, compliance; a person decides every case7, incl. sign-in, personal fields, golden cases, rollback signal

The agent in the examples behind these labs is a scripted stand-in, so these results show how the factory mechanics work, not how good any model is.

WatchAlgo in practice#

Mostly not applicable, and the reason is the lesson. Observed in the repository (docs/EVIDENCE.md, section 11): WatchAlgo had no external users, no change approval and no production data; it is a solo author's content site. Its demand was one person's decision, so there was nothing to classify: the author was the user, the business owner, the security reviewer and the maintainer. Observed (docs/EVIDENCE.md, matrix row 1 and section 12): even so, one dimension stayed unknown, the source of the 3,246 problem statements; no generator for problem.json survives. Its demand, which problems and why, is the one part of the WatchAlgo line the repository cannot explain. An enterprise factory cannot afford that gap for any product, because someone outside the factory will ask.

Enterprise translation#

At enterprise scale, demand intake becomes a service of the platform with a front door: a short form whose fields are the nine dimensions, a register that lives next to the spec in version control, and a review in which the platform team, a domain owner and, for higher tiers, security and compliance agree the tier and the pattern. The factory reads the register as data. A blocker on station 1 stops the run; a blocker on release lets the build proceed and holds promotion.

The ownership split is the one the series keeps returning to. The platform team owns the dimensions, the tiers and the patterns. Domain teams own the answers about their business. Security, compliance and the owners of upstream and downstream systems own their approvals. The factory owns none of the answers and must make every missing one visible. Enterprise reference patterns is where the classified demand meets a pattern; Enterprise governance owns who approves what.

Failure test#

The failure: a spec that passes every field check is built on an unclassified demand, and a dimension nobody asked about surfaces after the code exists. The concrete case here: the spec opens the decision route to the underwriting agent because the request said "make it smart".

How the factory catches it: in two places. Station 1 refuses the spec, because the pattern's constraint allows only underwriter to decide (the scratch run above). The unknowns register blocks station 1 while the identity provider and the email-to-submission question are open (the register run above). What neither catches is a dimension nobody wrote into the form; that is why the form's dimensions are fixed and reviewed, not improvised per request.

What to run or toggle: in the specmeter lab, set security to missing and watch the gate block; set unknowns to clear and watch the last two questions disappear. In the register script, set answer on U-01 and U-02 and station 1 may start, while the release stays blocked until compliance and maintainers answer.

Where to go deeper#

Checklist for Monday#

Exercises#

  1. The request says "brokers already have logins on the broker portal". Does that close U-01?
Answer 1Not until the owner confirms it

It narrows it. The register entry closes when the security architect confirms that the portal's identity provider can issue tokens to the new service, with which roles. A claim in the request is a lead, not an answer.

  1. An internal dashboard over public data. Which tier, and which approvals does the wizard give it?
Answer 2Low; two approvals

Low. The lab gives two: the spec owner signs the spec before any agent starts, and a person with merge rights reviews the change. No canary, no security or compliance sign-off.

  1. Why does the spec scoring 95 not mean the service can be built and released?
Answer 3The spec covers what the pattern declares

The score covers the spec's parts. Retention, the identity provider, the email channel, the maintainer and the service levels are not parts the pattern declares, so they never lower the score. They block the release all the same.

Advanced perspective#

Unknowns are work items, with their own lead timeSchedule the questions like the stations

An unknown is not a note; it is a task on someone else's queue. Treating register entries as work items, with an owner, a requested-by date and the station they block, lets the factory schedule around them: build the parts that no blocker touches, hold the parts that wait. The same scheduling rules from Looping over a large backlog apply: a blocker owned by a busy team is a bottleneck, and adding agents on the factory side does nothing to it.

Two failure modes are common. A register that grows without anyone answering becomes a museum; review its age every week and escalate the oldest blocker. And a register whose answers are recorded in chat rather than in the register loses them; the spec's next version should cite the answer's entry, so the next reader knows why a field holds the value it does.

When teams game the risk tierA tier that costs too much invites a lower one

If high tier means seven approvals and weeks of waiting, teams will describe their products as medium. The fix is not stricter policing alone. Make the tier's cost proportional (approvals that run in parallel, a security review that starts from the generated contract rather than from zero), make the signals objective (outside users: yes or no; regulated data: yes or no), and make the tier visible in the catalog, so a product's tier can be audited later against what it actually does. A product whose tier was lowered should carry the exception record with it.

Legacy behavior is a demand nobody can stateRecord it before you replace it

When a new intake service replaces an older path, the old path's behavior is part of the demand even though no one can describe it: odd defaults, silent truncations, fields downstream systems depend on. Asking people rarely recovers it. Recording does: capture real traffic in a safe environment, replay it against the new service, and compare outputs field by field. The differences are discovery questions with evidence attached, and each one goes into the register for the legacy system's owners to rule on: keep the behavior, or change it deliberately and tell its consumers.

This is the modernization adapter's core station in the next chapter, and the reason a modernization demand's critical path is almost always behavior recovery, not code.

"Make it smart" is a scope questionWhich step gets a model, and who decides

The phrase in the request hides the most consequential classification: where, if anywhere, a model belongs in the product. For the insurer there are two candidates: turning a broker's email into a draft submission, and writing a recommendation for the underwriter. Both are semantic work over variable text, which is where AI enters the factory says a model can earn its place. Neither may decide anything. Each adds dimensions to the demand: golden cases that define a good answer and an owner who maintains them, a run-time rule that a person reviews every draft or decides every case, and evaluation gates before release (Eval Engineering owns how those are built).

Classify each model step separately, with its own risk tier. An email extractor whose drafts a broker confirms is lower risk than a recommender read by an underwriter under time pressure.

In one breath#

An enterprise request is classified before any pattern is chosen: users and roles, outcomes, data and its classes, upstream and downstream systems, security, compliance, deployment targets, service levels and maintainers. What nobody knows yet goes into an unknowns register, each entry a discovery question with an owner and the station or release step it blocks, and a risk tier set from harm, reversibility and regulation decides the gates and approvals. The factory's checks catch the gaps a pattern declares, like a decision route opened to an agent; the rest of the critical path, integration, regulation, legacy behavior, security approval and undecided requirements, belongs to people, and a factory's honest job there is to make it visible.

The insurer's request is now classified: outside users, regulated personal data, an email channel upstream, events downstream, high risk. Which reference pattern fits that shape, and which parts of it are fixed? Enterprise reference patterns lays out eight patterns, what each holds fixed and lets vary, and maps the intake service to the two it combines.