Before
async function answerFoo(prompt: string) {
  return model.generate(prompt);
}

After
async function answerFoo(request: FooRequest) {
  const input = FooRequestSchema.parse(request);
  const context = await fooRetriever.retrieve(input.query);
  const output = await fooModel.generate(buildFooPrompt(input, context));
  return FooResponseSchema.parse(output);
}

Before
const model = trainFoo(loadAllData());
serve(model);

After
const dataset = datasetRegistry.load("foo", "v3");
const features = fooFeaturePipeline.transform(dataset);
const model = trainFoo(features, versionedTrainingConfig);
modelRegistry.register(model, evaluateFooModel(model, validationSet));

Before
deployModel(newestModelFile());

After
const candidate = modelRegistry.get("foo-model", "1.4.0");
requireApproval(candidate, ["model-owner", "risk-owner"]);
requirePolicyCompliance(candidate, fooModelPolicies);
deployModel(candidate);

Before
if (model.accuracy > 0.8) deploy(model);

After
const evaluation = evaluateModel(model, {
  datasets: [fooValidationSet, fooStressSet],
  metrics: [precision, recall, calibration, latencyP95],
  slices: ["foo-kind", "foo-region"],
});
requireThresholds(evaluation, fooModelThresholds);

Before
const output = model.predict(input as any);

After
const input = FooInferenceSchema.parse(rawInput);
const output = await inferenceRuntime.predict(fooModelVersion, input, {
  timeoutMs: 500,
  traceId,
});
return FooPredictionSchema.parse(output);

Before
const answer = await model.generate(`Answer: ${question}`);

After
const query = normalizeFooQuery(question);
const documents = await fooRetriever.search(query, { topK: 8 });
const groundedPrompt = buildGroundedFooPrompt(question, documents);
const answer = await model.generate(groundedPrompt);
return attachCitations(answer, documents);

Before
const results = foos.filter(foo => foo.text.includes(query));

After
const queryVector = await embedder.embed(query);
const results = await fooVectorIndex.search(queryVector, {
  topK: 10,
  filter: { tenantId },
});

Before
const fooLinks = new Map<string, string[]>();
fooLinks.set(foo.id, [bar.id, baz.id]);

After
const graph = new KnowledgeGraph();
graph.addNode(foo.id, "Foo", foo);
graph.addNode(bar.id, "Bar", bar);
graph.addEdge(foo.id, "DEPENDS_ON", bar.id);
graph.addEdge(bar.id, "PRODUCES", baz.id);

Before
return model.predict(foo.features);

After
const prediction = await model.predict(foo.features);
const explanation = await explainer.explain({
  modelVersion: model.version,
  input: foo.features,
  prediction,
});
return { prediction, explanation };

Before
return model.generate(userPrompt);

After
const input = await safety.validateInput(userPrompt);
const draft = await model.generate(input);
const checked = await safety.validateOutput(draft, { policy: "foo-assistant-v2" });
if (!checked.allowed) return safeRefusal(checked.reasons);
return checked.output;

Before
const answer = await model.generate("summarize: " + text);

After
const prompt = fooPromptTemplate.render({ task: "summarize", input: text, format: "bullet-points", maxWords: 100 });
const answer = await model.generate(prompt, { temperature: 0, stop: ["\n\n"] });

Before
serveModel(fooModel);

After
monitor.track(fooModel, {
  metrics: [inputDistribution, predictionConfidence, groundTruthLag],
  alertOn: { populationStabilityIndex: 0.2 },
});

Before
const answer = await model.generate(question);

After
const agent = createFooAgent({ tools: [searchFoos, calculator, fooStore], maxSteps: 8 });
const answer = await agent.run(question);

Before
function handle(req) {
  const foo = db.query(req.body.sql);
  render(foo); email(foo); audit(foo); cache(foo);
}

After
class CreateFoo {
  constructor(private readonly foos: FooRepository, private readonly events: EventPublisher) {}
  execute(input: CreateFooInput) { const foo = Foo.create(input); this.foos.save(foo); this.events.publish(fooCreated(foo)); }
}

Before
class FooManager {
  createFoo() {} priceFoo() {} renderFoo() {} emailFoo() {} auditFoo() {} shipFoo() {}
}

After
class FooFactory { create(input: CreateFooInput): Foo {} }
class FooPricer { price(foo: Foo): Money {} }
class FooShipper { ship(foo: Foo): void {} }

Before
class FooService {
  private readonly store = new SqlFooStore();
}

After
class FooService {
  constructor(private readonly store: FooStore) {}
}

Before
type FooApi = { id: string; label: string };
type FooDb = { id: string; name: string; extra: string };

After
const FooSchema = schema({ id: fooIdSchema, name: nonEmptyString });
type Foo = Infer<typeof FooSchema>;
fooApi.use(FooSchema);
fooDb.use(FooSchema);

Before
function saveFoo(foo) { return db.insert(foo); }

After
interface Foo { id: FooId; name: NonEmptyString; }
function saveFoo(foo: Foo): Promise<void> { return fooStore.save(foo); }

Before
const client = new FooClient("https://foo.prod.example", "sk_live_abc123");

After
const config = FooConfigSchema.parse({ url: process.env.FOO_URL, key: process.env.FOO_KEY });
const client = new FooClient(config);

Before
let currentFoo = null;
function setFoo(f) { currentFoo = f; }
function useFoo() { return currentFoo.name; }

After
class FooContext {
  constructor(private readonly foo: Foo) {}
  name() { return this.foo.name; }
}

Before
app.get("/foo/:id", async (req, res) => res.json(await ormFoo.findByPk(req.params.id)));

After
app.get("/foo/:id", async (req, res) => res.json(toFooDto(await getFoo.execute(req.params.id))));

Before
const CONVENTION = "remember to prefix every foo id with foo_";

After
export const rule = { id: "valid-foo-id", check: (id: string) => id.startsWith("foo_") };

Before
function processFoo(foo) { doWork(foo); }

After
function processFoo(foo: Foo) {
  logger.info("foo.process.start", { fooId: foo.id });
  const result = doWork(foo);
  logger.info("foo.process.done", { fooId: foo.id, outcome: result.status });
}

Before
await payment.charge(foo);

After
const outcome = await payment.charge(foo);
if (!outcome.ok) { logger.error("foo.charge.failed", outcome); throw new ChargeFailedError(foo.id); }

Before
try { await ship(foo); } catch { }

After
try { await ship(foo); } catch (error) { logger.error("foo.ship.failed", error); metrics.increment("foo.ship.failure"); throw new ShipFailedError(foo.id); }

Before
app.get("/foo", () => ({ label: foo.name }));

After
app.get("/v2/foo", () => ({ name: foo.name }));
app.get("/v1/foo", () => ({ label: foo.name }));

Before
async function createFoo(foo) {
  await http.post("bar-service/validate", foo);
  await http.post("baz-service/price", foo);
  await http.post("qux-service/save", foo);
}

After
async function createFoo(input: CreateFooInput) {
  const foo = Foo.create(input);
  await fooStore.save(foo);
  await outbox.append(fooCreated(foo));
}

Before
const taxA = value * 0.2;
const taxB = other * 0.2;
const taxC = more * 0.2;

After
const FOO_TAX_RATE = 0.2;
function taxFoo(value: number) { return value * FOO_TAX_RATE; }

Before
class Foo {
  renderHtml() {} saveToSql() {} sendEmail() {} parseCsv() {}
}

After
class Foo {}
class FooView { render(foo: Foo): string {} }
class FooStore { save(foo: Foo): Promise<void> {} }

Before
function totalFoo(bar: Bar) { return bar.items.reduce((s, i) => s + i.price * i.qty, 0); }

After
class Bar { total(): Money { return this.items.reduce((s, i) => s + i.subtotal(), 0); } }

Before
bar.foo._internalState.status = "ready";

After
bar.foo.markReady();

Before
const city = foo.getOwner().getAddress().getCity().getName();

After
const city = foo.ownerCityName();

Before
class FooService {
  save(foo: Foo) { return this.store.save(foo); }
  find(id: FooId) { return this.store.find(id); }
}

After
const fooStore: FooStore = new SqlFooStore();

Before
function shipFoo(street: string, city: string, zip: string, country: string) {}

After
interface Address { street: string; city: string; zip: string; country: string; }
function shipFoo(address: Address) {}

Before
function transfer(fooId: string, amount: number, currency: string) {}

After
class Money { constructor(readonly amount: number, readonly currency: Currency) {} }
function transfer(fooId: FooId, money: Money) {}

Before
if (foo.status === "reddy") ship(foo);

After
enum FooStatus { Ready, Shipped }
if (foo.status === FooStatus.Ready) ship(foo);

Before
createFoo(true, false, true);

After
createFoo({ active: true, archived: false, notify: true });

Before
function makeFoo(a, b, c, d, e, f, g) {}

After
interface MakeFooInput { a: A; b: B; c: C; d: D; e: E; f: F; g: G; }
function makeFoo(input: MakeFooInput) {}

Before
if (foo.retries > 3) fail(foo);

After
const MAX_FOO_RETRIES = 3;
if (foo.retries > MAX_FOO_RETRIES) fail(foo);

Before
abstract class AbstractFooProviderFactoryBase<T> { abstract create(): T; }

After
function createFoo(input: CreateFooInput): Foo { return Foo.create(input); }

Before
interface FooStrategy { run(): void; }
class OnlyFooStrategy implements FooStrategy { run() {} }

After
function runFoo() {}

Before
const foo = fooFactoryProvider.getFactory().createBuilder().build();

After
const foo = Foo.create(input);

Before
const config = parseFooConfig(runRegexOverEverything(rawYaml));

After
const config = FooConfigSchema.parse(yaml.load(rawYaml));

Before
class FooSingletonFactoryObserverProxy {}

After
class FooService { constructor(private readonly store: FooStore) {} }

Before
function saveFoo(foo) {
  legacySaveV1(foo);
  if (false) legacySaveV2(foo);
  newSave(foo);
}

After
function saveFoo(foo: Foo) { return fooStore.save(foo); }

Before
function computeFoo() {}
function computeFooOld() {}
function computeFooDeprecated() {}

After
function computeFoo() {}

Before
foo.init();
foo.configure();
foo.start();

After
const foo = Foo.start(config);

Before
function getFoo(id: FooId) { audit.log(id); return fooStore.find(id); }

After
function getFoo(id: FooId) { return fooStore.find(id); }
function auditFooAccess(id: FooId) { audit.log(id); }

Before
globalThis.fooFlag = true;
function runFoo() { if (globalThis.fooFlag) go(); }

After
function runFoo(options: { enabled: boolean }) { if (options.enabled) go(); }

Before
function saveFoo(foo) { return CurrentTenant.get().db.save(foo); }

After
function saveFoo(foo: Foo, tenant: Tenant) { return tenant.db.save(foo); }

Before
function a() { return null; }
function b() { throw "bad"; }
function c() { return { error: true }; }

After
function a(): Result<Foo, FooError> {}
function b(): Result<Bar, FooError> {}
function c(): Result<Baz, FooError> {}

Before
try {
  return await fooStore.find(id);
} catch (notFound) {
  return fooStore.create(id);
}

After
const foo = await fooStore.find(id);
return foo ?? fooStore.create(id);

Before
const foo = find(id);
if (foo) use(foo);

After
const foo = find(id) ?? Foo.none();
foo.use();

Before
class Foo { status: string; }
function shipFoo(foo: Foo) { if (foo.status === "ready") foo.status = "shipped"; }

After
class Foo {
  private status = FooStatus.Ready;
  ship() { if (this.status !== FooStatus.Ready) throw new NotReadyError(); this.status = FooStatus.Shipped; }
}

Before
function createFooHandler(req) {
  validate(req); price(req); tax(req); persist(req); notify(req);
}

After
class CreateFoo {
  constructor(private readonly foos: FooRepository) {}
  execute(input: CreateFooInput) { const foo = Foo.create(input); return this.foos.save(foo); }
}

Before
class FooController {
  create(req) { const foo = { ...req.body }; if (!foo.name) throw 0; db.insert(foo); email(foo); }
}

After
class FooController {
  constructor(private readonly createFoo: CreateFoo) {}
  create(req: Request) { return this.createFoo.execute(req.body); }
}

Before
class FooRepository { findActiveFoosForBarInRegionSortedByBaz() {} }

After
class FooRepository { find(spec: FooSpecification): Foo[] { return this.query(spec.toQuery()); } }

Before
export function formatFoo() {}
export function parseBar() {}
export function hashBaz() {}

After
export const fooFormatter = { format(foo: Foo): string {} };
export const barParser = { parse(raw: string): Bar {} };

Before
class Foo { @Column() name: string; @OneToMany() bars: Bar[]; }

After
class Foo { constructor(readonly name: string, readonly bars: readonly Bar[]) {} }
class FooEntity { @Column() name: string; }

Before
import { BlobStore } from "acme-blob-sdk";
function saveFoo(foo) { return new BlobStore().putObject(foo); }

After
interface FooBlobStore { put(foo: Foo): Promise<void>; }
function saveFoo(foo: Foo, store: FooBlobStore) { return store.put(foo); }

Before
import { bar } from "./bar";
export const foo = () => bar();
import { foo } from "./foo";
export const bar = () => foo();

After
export const foo = (run: () => void) => run();
export const bar = () => {};
foo(bar);

Before
fooService.callsAtStartup(barService);
barService.callsAtStartup(fooService);

After
fooService.publishes(fooReady);
barService.subscribes(fooReady);

Before
const foo = await a();
const bar = await b(foo);
const baz = await c(bar);
return slowSyncCall(a, b, c);

After
const [foo, bar, baz] = await Promise.all([a(), b(), c()]);

Before
const results = [];
for (const id of fooIds) results.push(await fooApi.get(id));

After
const results = await fooApi.getMany(fooIds);

Before
const foos = await fooStore.all();
for (const foo of foos) foo.bar = await barStore.find(foo.barId);

After
const foos = await fooStore.all();
const bars = await barStore.findMany(foos.map(f => f.barId));

Before
fooCache.set(request.path, response);

After
if (response.ok && response.cacheable) {
  fooCache.set(cacheKey(request.identity, request.path), response, { ttlMs: 60_000 });
}

Before
while (true) { try { return await call(); } catch { } }

After
return retry(call, { attempts: 5, backoff: exponentialJitter(), giveUp: dlq });

Before
const foo = await fetch(fooUrl);

After
const foo = await fetch(fooUrl, { signal: AbortSignal.timeout(5000) });

Before
stream.on("data", d => queue.push(process(d)));

After
stream.pipe(new BoundedFooProcessor({ highWaterMark: 100 }));

Before
const total = Number(a) + Number(b);
save(total);

After
const total = Money.add(Money.parse(a), Money.parse(b));
save(total);

Before
const foo = await load(id);
foo.count += 1;
await save(foo);

After
await fooStore.update(id, { count: increment(1) }, { expectedVersion: foo.version });

Before
await db.save(foo);
await searchIndex.add(foo);

After
await db.save(foo);
await outbox.append(fooCreatedEvent(foo));

Before
await primaryDb.write(foo);
const view = await replicaDb.read(foo.id);

After
await primaryDb.write(foo);
const view = await readAfterWrite(foo.id, { consistency: "read-your-writes" });

Before
if (password.length > 0) grantFooAccess(user);

After
const verified = await verifyPassword(password, user.passwordHash);
if (!verified) throw new UnauthorizedError();
grantFooAccess(user);

Before
if (user.role === "admin") deleteFoo();
if (user.role === "admin" || user.id === foo.owner) editFoo();

After
if (policy.can(user, "delete", foo)) deleteFoo();
if (policy.can(user, "edit", foo)) editFoo();

Before
const key = "sk_live_abc123";
const dbPass = "hunter2";

After
const key = await secrets.get("foo.api.key");
const dbPass = await secrets.get("foo.db.password");

Before
logger.info("created foo", { email: user.email, ssn: user.ssn });

After
logger.info("created foo", { userId: user.id });

Before
logger.info("entering loop");
for (const f of foos) logger.info("iter", f);

After
logger.info("foo.batch.processed", { count: foos.length, durationMs });

Before
if (lastFooLogLine.includes("FooReady")) startBarProcessor();

After
fooEvents.on("FooReady", startBarProcessor);

Before
const RUNBOOK = "on failure, ssh in and run restart-foo.sh";

After
health.onUnhealthy(() => orchestrator.restart("foo"));

Before
deployEverything("foo", "bar", "baz");

After
release("foo", { strategy: canary(0.1) });

Before
await db.exec("ALTER TABLE foo DROP COLUMN legacy_name");

After
await migrate({ up: addFooName, down: restoreFooName });

Before
const ARCHITECTURE = designAllModulesForNextFiveYears();

After
const foo = defineModule("foo", { exports: { createFoo } });
registry.add(foo);

Before
class AbstractFooMetaStrategyOrchestrationEngineFactory {}

After
class CreateFoo { execute(input: CreateFooInput): Foo {} }

Before
function addFooFeature() { hack(); patch(); bypassLint(); }

After
function addFooFeature(input: CreateFooInput) { return createFoo.execute(input); }

Before
test.e2e("create foo", fullBrowserFlow);
test.e2e("rename foo", fullBrowserFlow);
test.e2e("delete foo", fullBrowserFlow);

After
test.unit("FooValidator rejects an empty name", () => expect(() => validateFoo({ name: "" })).toThrow());
test.integration("FooRepository persists a Foo", async () => {
  await fooRepository.save(foo);
  expect(await fooRepository.find(foo.id)).toEqual(foo);
});
test.e2e("the critical signup path", criticalPathOnly);

Before
const store = { save: fn(), find: fn().returns(foo) };

After
const store = new InMemoryFooStore();
runFooStoreContract(store);

Before
test.retry(5)("foo works sometimes", async () => { await sleep(random()); expect(await getFoo()).toBeTruthy(); });

After
test("foo is created deterministically", async () => { const foo = await createFoo.execute(input); expect(foo.id).toBe(expectedId); });

Before
const a = model.run("summarize this foo: " + foo);
const b = model.run("pls summarize foo " + foo);

After
const summary = model.run(FOO_PROMPTS.summarize({ foo }));

Before
const answer = await model.run(question);
return answer;

After
const context = await retrieve(question);
const answer = await model.run(FOO_PROMPTS.answer({ question, context }));
return withCitations(answer, context);

Before
const result = await model.run(prompt);

After
const result = await model.run(prompt, { model: "foo-llm-2024-06", temperature: 0 });
logger.info("foo.inference", { model: result.model });

Before
approveFooArchitecture();

After
const assessment = assess(fooArchitecture, {
  dimensions: ["modularity", "reliability", "security", "operability"],
  evidence: collectArchitectureEvidence(fooSystem),
});
requirePassingAssessment(assessment);

Before
mergeFooDesign();

After
const review = architectureReview({
  context: fooContext,
  decisions: fooDecisions,
  risks: fooRisks,
  qualityAttributes: fooQualityAttributes,
});
review.requireApproval(["architecture-owner", "security-owner"]);

Before
implementFooDesign(fooDesign);

After
const review = designReview(fooDesign, {
  contracts: validateContracts,
  failureModes: analyzeFailureModes,
  testability: assessTestability,
});
if (!review.approved) throw new Error("design rejected");

Before
git.merge(fooChange);

After
const review = codeReview(fooChange);
review.require({ approvals: 2, passingChecks: ["tests", "types", "security", "architecture"] });
git.merge(review.approvedCommit);

Before
renameFooField("name", "label");

After
const impact = dependencyGraph.impactOf({
  contract: "FooV1.name",
  change: "rename-to-label",
});
for (const consumer of impact.consumers) requireMigration(consumer);
renameFooField("name", "label");

Before
declareFooSystemReady();

After
const target = fooTargetArchitecture();
const current = inspectFooArchitecture();
const gaps = compareArchitecture(current, target);
for (const gap of gaps) assignRemediation(gap);

Before
architectureGuidelines.write("Foo domain must not import infrastructure");

After
const fitness = forbidImports({ from: "src/foo/domain/**", to: "src/foo/infrastructure/**" });
pipeline.enforce(fitness);

Before
designFooService();

After
const attributes = defineQualityAttributes({
  availability: "99.95%",
  p95LatencyMs: 200,
  recoveryTimeMinutes: 5,
  dataLossSeconds: 0,
});
designFooService(attributes);

Before
chooseFooDatabase("postgres");

After
const adr = recordDecision({
  id: "ADR-0042",
  title: "Use PostgreSQL for Foo persistence",
  status: "accepted",
  context: fooPersistenceForces,
  decision: "postgres",
  consequences: fooPersistenceConsequences,
});

Before
designFinalFooArchitecture();
freezeArchitectureForever();

After
const fooArchitecture = evolveArchitecture({
  current: minimumFooArchitecture,
  fitnessFunctions: fooFitnessFunctions,
  nextChange: highestValueArchitectureChange,
});

Before
buildServiceMesh();
buildGlobalEventBus();
buildPluginPlatform();
createFooEndpoint();

After
const architecture = defineMinimumArchitecture({
  useCase: "create-and-read-foo",
  components: ["foo-api", "foo-store"],
  deferredUntilForced: ["service-mesh", "plugin-platform"],
});

Before
copyLegacyFooModule();
retainLegacyFooFlags();
retainLegacyFooSchema();

After
const fooSystem = designFromCurrentForces({
  domain: fooDomain,
  constraints: currentConstraints,
  contracts: currentContracts,
});

Before
useMicroservicesBecauseIndustryUsesMicroservices();

After
const forces = identifyForces(fooProblem);
const invariants = deriveInvariants(forces);
const design = synthesizeArchitecture({ forces, invariants });