The Language That Makes AI Build Differently

This is a shareable catalog of unusually specific phrases and development approaches Cory has used with AI systems. It separates Cory's conversational wording from pasted or collaboratively drafted specifications and from machine chatter.

The strongest short list#

1. Genetic agent-strategy evolution with winner retention and branch fallback
2. “Track stats and find ‘genetic’ wins.”
3. “The ‘genetics’ should be tracked and control which ‘agent’ strategies get promoted.”
4. “Keep track of previous winners so they can be mixed in again later if future genetics fail after a branch.”
5. Tree-and-leaves agent orchestration
6. “Each can act as a ‘leaf’ on the branch of a ‘tree’ while a manager agent keeps track of the branch, and you control the trunk.”
7. Cost-tiered retrieval and synthesis — cheap leaf models retrieve; stronger models supervise and synthesize.
8. “Kick off 24 agents … (4 agents per).”
9. “Spin up 10 agents and parallalize the hell out of this.” [sic]
10. Hybrid deterministic–AI development
11. “Local deterministic methods along with AI.”
12. “A RAG-driven AI along with deterministic data-driven processes.”
13. Best-guess deduplication with fact preservation
14. Hard-facts-first normalization
15. “SUPER deep RAG with tools.”
16. Monte Carlo analysis with an explicit assumption ledger
17. “Monte Carlo simulation with tornado analysis.”
18. Known / correlated / inferred / deduced evidence classes
19. “A ‘Sherlock Holmes’ app that takes literally everything it can into account.”
20. Real telemetry, not spinner theater
21. “Updates that are REAL so they never feel like the system is hung up.”
22. “Valid signals promote to human review.”
23. “One last final HIL review before we kick off and start.”
24. Move and improve
25. “Refactor, remix, or rethink.”
26. “Try to not throw out the baby with the bathwater.”
27. “Treat it as advanced lorem ipsum.”
28. “Accuracy first.” / “Triple check it.”
29. “Best of breed from both.”
30. Science with drama and cinema—without straying outside the science

Verified conversational phrases and what they mean#

Genetic strategy evolution#

“Track stats and find ‘genetic’ wins that we can work into future efforts.”

“The ‘genetics’ should be tracked and control which ‘agent’ strategies get promoted.”

“Keep a constant improvement, but keep track of previous winners so they can be mixed in again later if future genetics fail after a branch.”

This is a concrete evolutionary system: measure strategy outcomes, promote successful agent strategies, branch into variants, retain historical winners, and reintroduce or remix those winners if a descendant branch degrades.

Recommended name: genetic agent-strategy evolution with winner retention and branch fallback.

Tree-and-leaves orchestration#

“Each can act as a ‘leaf’ on the branch of a ‘tree’ while a manager agent keeps track of the branch, and you control the trunk, IE, the planning and architecture.”

“A proper ‘tree and leaves’ setup.”

“The cheaper model retrieve[s] and the more expensive model do[es] the supervision and final synthesis.”

The topology is explicit:

• trunk: planning, architecture, authority, and final synthesis;
• branches: managers coordinating workstreams;
• leaves: bounded retrieval and execution;
• economics: inexpensive models do wide work; the strongest model performs supervision and judgment.

Recommended name: hierarchical, cost-tiered tree-and-leaves orchestration.

Deliberately overprovisioned parallelism#

“Spin up 10 agents and parallalize the hell out of this.” [sic]

“Kick off 24 agents … (4 agents per).”

“Let a side agent do it while the main swarm does other work.”

“Work slowly and carefully, but with enough agents to make this FAST.”

This combines stream allocation, side-agent isolation, wide parallel execution, and centralized quality control.

Recommended name: bounded swarm parallelism with per-stream staffing.

Hybrid deterministic–AI systems#

“Use local deterministic methods along with AI.”

“A combination of a RAG-driven AI along with deterministic data-driven processes and information baked in where it’s most appropriate.”

“A pseudo-code / hybrid AI/(LLM/ML)/deterministic code/programmatic guide … with decision points.”

The recurring principle is to assign each part of a system to the technique best suited to it: deterministic code for repeatability and constraints, retrieval for grounded knowledge, and models for interpretation and synthesis.

Recommended name: decision-point hybridization of deterministic, retrieval, ML, and LLM components.

Hard-facts-first normalization#

“Run best-guess deduplication so that the set of work is reduced as much as we can while still getting all the facts.”

“First, the ‘hard facts’ module … then remodel the dataset with those now known/fixed values.”

“Approve, discard, or edit the fact. Once that’s done, all statements … are adjusted to match this information.”

The method is to infer a reusable factual substrate; let an authoritative user approve, edit, or reject it; probabilistically deduplicate without losing distinct facts; remodel downstream language against the approved facts; and preserve ambiguous alternatives for best-of-breed selection.

Recommended name: human-approved hard-fact normalization with loss-averse semantic deduplication.

Deep RAG with tools and tenant context#

“The VERY best ways to create a SUPER deep RAG with tools.”

“Hundreds to thousands of docs, an entire database schema, and other support data.”

“Allow the user to upload an abstracted version of their own database and config to enable full support knowledge.”

This is a tool-using, schema-aware, tenant-contextual retrieval system—not document chat.

Recommended name: schema-aware deep RAG with tools and abstracted tenant configuration.

Multi-mode answer evaluation#

“Answer the question in ALL THREE modes, and the user/SME can then independently rate and judge each one.”

“Run the other two deeper ones in parallel to speed things up.”

This creates a productized model/strategy bakeoff: produce comparable answers, separate the judging step, collect SME ratings, and use those ratings to guide routing and improvement.

Recommended name: parallel multi-mode answer bakeoff with independent SME scoring.

Monte Carlo with transparent assumptions#

“Use Monte Carlo, local execution, Apple Metal shaders on the local GPU, whatever is needed to accomplish the task well.”

“Expose and explain the exact assumptions, methods, data, etc. used in the simulation/analysis process.”

“Monte Carlo simulation with tornado analysis.”

Recommended name: locally accelerated Monte Carlo with tornado sensitivity analysis and an explicit assumption ledger.

Sherlock Holmes analysis#

“A ‘Sherlock Holmes’ app that takes literally everything it can into account.”

“Use both inductive reasoning and deductive reasoning.”

“Consider all options and approaches, including OSINT … as well as directly available information from the photograph.”

Recommended name: multimodal Sherlock-Holmes analysis combining observation, OSINT, induction, and deduction.

Evidence gradients instead of false certainty#

“If not correlated, or confirmed, but it can still be inferred or deduced, then include [it] under those two classes, beside the known.”

“A direct passage IS sufficient if clear.”

“Only look at what we can reasonably infer or deduce.”

“Give it room to be wrong.”

“Green, yellow or red” claims.

The pattern is to preserve useful uncertainty while visibly separating direct evidence, corroboration, inference, deduction, contradiction, and unresolved claims.

Recommended name: epistemically labeled evidence and inference.

Signal-gated human attention#

“AI tries to assess and verify—if valid signals, promote to human review.”

This makes human review a scarce resource controlled by verification strength, rather than a mandatory step for every input.

Recommended name: AI verification triage with signal-gated human escalation.

Observable autonomy#

“Build a FULLY autonomous system.”

“A human should be able to CLEARLY watch and see all activity … all the telemetry and data is exposed.”

“Updates that are REAL so they never feel like the system is hung up.”

Recommended name: observable autonomy with truthful, gamified execution telemetry.

Human-in-the-loop launch gates#

“One last final HIL review before we kick off and start.”

“Be careful, we’re about to take off and do this, so it’s now the final HIL review.”

The human is used as a high-value boundary at commitment or launch, not as a substitute for autonomous preparation.

Recommended name: terminal HIL gating after autonomous preparation.

Reversible progress and protected sources#

“Do not delete anything.”

“This should NEVER touch source.”

“Set this as a major checkpoint.”

“Do not publish.”

“Preserve DISPUTED or INSUFFICIENT outcomes rather than forcing agreement.”

Recommended name: checkpointed, source-preserving, reversible execution.

Refactor, remix, or rethink#

“Consider if the current approach is optimal—if you need to refactor, remix, or rethink, go for it.”

“Look at everything one more time, and consider even minor refactors—or major if best.”

“The job was not to refactor everything; it was to polish what we had.”

This distinguishes intentional architecture change from indiscriminate rewriting.

Recommended name: scope-aware whole-system refactoring.

Move and improve#

“We’re doing a BETTER job than it is currently; this is a move and improve!”

Migration is treated as an improvement event, not a byte-for-byte relocation.

Advanced lorem ipsum#

“The words were so placeholders and you just improved the placeholders.”

“What story are we telling? Look at that, then the ‘container’ we have to work in, and then fill it up with the BEST content.”

“Stop trying to use what we have; consider it advanced lorem ipsum.”

Recommended name: narrative-first content refactoring instead of placeholder polishing.

Accuracy before velocity—velocity through parallelism#

“RESEARCH EACH THING CAREFULLY AND TRIPLE CHECK IT!!! accuracy first.”

“Work hard, spin up 10 agents and parallalize the hell out of this.” [sic]

The combination is distinctive: do not trade correctness for speed; create speed by adding independent workstreams and verification.

Science with cinema#

“Keep it scientific, but also do keep the drama and ‘feel’.”

“A site for scientists, but with all that drama and cinema … just not straying outside of the science for the drama.”

Recommended name: cinematic scientific communication under a truth-preservation constraint.

Benchmark, merge, and beat#

“Use the best of breed from both [the previous work] and your efforts to go forward.”

“Try to not throw out the baby with the bathwater.”

“Meet/exceed this by a LOT.”

Recommended name: benchmark-and-beat synthesis with selective legacy retention.

Tip-of-the-spear development radar#

“It’s a never-ending flow.”

“Regularly go out and find all the latest stuff.”

“If it’s not being talked about by someone it’s either crap or SUPER new, so we can relax for a day or two while the real tip of the spear gets a hand on the tools.”

Recommended name: social-signal-filtered emerging-tool radar.

Additional signature language#

Cory-supplied specification language#

These appeared inside Cory's user messages, but often as long goals, role prompts, or collaboratively drafted specifications. They are approaches Cory deliberately supplied and endorsed; they are not all claimed as spontaneous personal coinages.

• permission-aware operating intelligence layer
• verified operating graph
• source-backed operational truth
• immutable evidence capture
• permission before retrieval
• AI outputs stored as cited fact claims
• confidence and verification ladders
• cross-source conflict detector
• stale project truth detector
• responsibility-aware rollups
• derived-fact permission inheritance
• prompt-injection-resistant source processing
• counterpart cross-audit
• dual-master outcome
• explicit INSUFFICIENT EVIDENCE next test
• strongest benign explanation
• best next falsification test

Researched behavioral control vocabulary#

This section is research-derived, not a claim that Cory previously coined or used every term. These are compact terms of art that can make an AI or engineering team execute a recognizable procedure without requiring the human to restate the procedure each time.

They are not magic words. The most reliable compact instruction is:

Use [term]; produce [required artifact]; stop only when [acceptance condition].

The 15 highest-leverage additions#

AI reasoning, retrieval, and evaluation controls#

ReAct loop#

Compact instruction:

Run a ReAct loop: reason, act through a tool, inspect the observation, update the plan, and repeat until the stated terminal condition is verified.

This should produce an interleaved action/observation trajectory rather than a long speculative plan followed by blind execution. The original ReAct work defines the method as interleaving reasoning traces and task-specific actions so observations can update the plan. ReAct paper↗

Chain-of-Verification (CoVe)#

Compact instruction:

Apply Chain-of-Verification: draft, generate verification questions, answer each independently, then write a corrected final answer with unsupported claims removed.

“Independently” matters: the verification answers should not simply inherit the draft's assumptions. Chain-of-Verification paper↗

Self-consistency#

Compact instruction:

Use self-consistency over at least N independent solution paths; aggregate the result and report disagreement.

This means sampling diverse reasoning paths and selecting the answer most consistently reached—not asking one model to say “I agree with myself.” Self-consistency paper↗

Tree of Thoughts with pruning#

Compact instruction:

Use Tree of Thoughts: branch into materially different approaches, score intermediate states against the objective, prune weak branches, and backtrack before committing.

This is for problems requiring search, strategic lookahead, or recovery from an early bad choice. Tree of Thoughts paper↗

Reflexion loop#

Compact instruction:

Run a Reflexion loop: attempt, score against external feedback, write the failure lesson into episodic memory, and retry with the lesson explicitly applied.

The defining feature is verbal reinforcement stored for later trials, not model-weight training. Reflexion paper↗

HyDE retrieval#

Compact instruction:

Use HyDE only as a retrieval bridge: generate a hypothetical ideal document, embed it, retrieve real documents near it, and discard the hypothetical text as evidence.

That final constraint is essential because the generated hypothetical document may contain false details; it exists to improve retrieval. HyDE paper↗

Corrective RAG (CRAG)#

Compact instruction:

Use CRAG: evaluate retrieval first; if correct, refine and use it; if ambiguous, supplement it; if incorrect, reject it and retrieve elsewhere.

This prevents low-quality retrieval from being passed unquestioned into generation. Corrective RAG paper↗

GraphRAG global search#

Compact instruction:

Use GraphRAG global search for corpus-wide questions: extract an entity graph, form communities, summarize each community, map the question across summaries, then reduce the partial answers.

Use this for themes, patterns, and whole-corpus sensemaking; ordinary chunk retrieval is often better for a narrow fact lookup. GraphRAG paper↗

RAG triad evaluation#

Compact instruction:

Evaluate the RAG triad separately: retrieval relevance/coverage, generation faithfulness to context, and final-answer quality. Do not collapse them into one score.

This makes a failed answer diagnostically useful: the team can tell whether retrieval missed, context was noisy, or generation misused good evidence. RAGAS paper↗

Blinded, position-swapped LLM judging#

Compact instruction:

Run a rubric-bound pairwise judge blind to model identity; swap A/B positions; require reasons tied to rubric criteria; send inconsistent verdicts to human review.

The qualifiers are necessary because LLM judges can exhibit position, verbosity, and self-enhancement biases. MT-Bench / LLM-as-a-Judge paper↗

Software design and testing controls#

Architectural fitness function#

Compact instruction:

Express this quality as an architectural fitness function and run it continuously in CI and production telemetry.

A fitness function objectively tests how close an implementation is to an architectural goal. It converts “keep the architecture good” into executable governance. Thoughtworks definition↗

This is especially compatible with Cory's genetic language: the fitness function defines what wins; genetic strategy evolution decides what gets promoted.

Quality-attribute scenario#

Compact instruction:

Write a measurable quality-attribute scenario: source, stimulus, environment, affected artifact, expected response, and response measure.

Instead of saying “make it scalable,” this produces something testable such as a workload spike, the environment in which it occurs, the component affected, and the maximum acceptable latency. SEI quality-attribute scenario↗

Architectural Decision Record (ADR)#

Compact instruction:

Write an ADR with status, context, decision, rejected alternatives, and consequences; accepted ADRs are immutable and later decisions supersede them.

This preserves why a decision was made and prevents the same debate from restarting without new evidence. AWS ADR process↗

Branch by abstraction#

Compact instruction:

Migrate by branch-by-abstraction: place an interface around the old behavior, build the replacement behind it, compare both, switch callers incrementally, then delete the old implementation and temporary abstraction if appropriate.

The codebase remains buildable and releasable during replacement. Branch by Abstraction↗

Strangler Fig migration#

Compact instruction:

Use a Strangler Fig migration: intercept one bounded capability at a time, route it to the replacement, verify parity, and shrink the legacy surface incrementally.

This instructs incremental replacement rather than a big-bang rewrite. Azure architecture pattern catalog↗

Feature flag with kill switch#

Compact instruction:

Ship behind a feature flag with explicit targeting context, a safe default, owner, expiry/removal date, observability, and a tested kill switch.

“Feature flag” alone can create permanent configuration debt; the lifecycle qualifiers turn it into a controlled rollout mechanism. OpenFeature evaluation context↗

Property-based testing#

Compact instruction:

Write property-based tests around invariants and metamorphic relations; generate valid and adversarial inputs; shrink every failure to a minimal reproducer.

This changes testing from a handful of examples to guarantees checked over generated examples. Hypothesis documentation↗

Mutation testing#

Compact instruction:

Run mutation testing on critical logic; require the test suite to kill behavior-changing mutants; review every survivor as a missing assertion, equivalent mutant, or unreachable path.

The important deliverable is not a vanity mutation score but an adjudicated survivor list.

Stryker mutation-testing documentation↗

Consumer-driven contract testing#

Compact instruction:

Create consumer-driven contracts from real consumer behavior, publish them, verify them against each provider version, and block incompatible deployment.

This makes provider compatibility executable and allows services to deploy independently without relying only on a brittle end-to-end environment. Pact contract-testing process↗

Test pyramid#

Compact instruction:

Apply the test pyramid: many fast unit/component tests, focused integration and contract tests, and a small set of high-value end-to-end journeys.

This phrase should trigger a distribution decision, not simply “add more tests.” Practical Test Pyramid↗

Distributed-systems and reliability controls#

Idempotent consumer#

Compact instruction:

Assume at-least-once delivery; make the consumer idempotent using a stable operation key, atomic deduplication, and replay tests.

Processing the same message repeatedly must have the same external effect as processing it once. Azure pattern catalog↗

Transactional outbox#

Compact instruction:

Use a transactional outbox: commit state change and outbound event in one local transaction; publish asynchronously; make downstream consumers idempotent.

This avoids the dual-write gap between a database commit and message publication.

AWS Transactional Outbox pattern↗

Saga with compensating transactions#

Compact instruction:

Model this as a saga: define each local transaction, success event, failure event, retry policy, and idempotent compensating action; test failure after every step.

This is a distributed consistency protocol, not merely “eventual consistency.” AWS cloud design patterns↗

Circuit breaker + bounded retry#

Compact instruction:

Use bounded exponential-backoff retry with jitter for transient faults, then open a circuit breaker for persistent faults; define half-open probes and fallback behavior.

Retries without a breaker can amplify failure; breakers without recovery probes can freeze service unnecessarily. Azure pattern catalog↗

Bulkhead isolation#

Compact instruction:

Apply bulkheads by tenant, dependency, or workload class; isolate queues, connection pools, concurrency, and quotas so one failure cannot exhaust every lane.

This is the precise resilience analogue of Cory's “stick to our lanes.” Azure Bulkhead pattern↗

Queue-based load leveling + competing consumers#

Compact instruction:

Buffer bursty intake with queue-based load leveling; scale competing consumers from queue depth; define backpressure, dead-letter policy, retry ceiling, and ordering requirements.

This turns “parallelize it” into controlled asynchronous throughput. Azure Competing Consumers pattern↗

OpenTelemetry semantic conventions#

Compact instruction:

Instrument traces, metrics, logs, and resources using OpenTelemetry semantic conventions; propagate correlation context end to end.

This causes telemetry from different components to share names and meaning rather than becoming incompatible logging islands. OpenTelemetry semantic conventions↗

SLO-driven error budget#

Compact instruction:

Define user-centered SLIs and SLOs; compute the error budget; freeze risky launches when burn exceeds policy; resume when reliability is restored.

An error budget is an operational control loop balancing release velocity and reliability. Google SRE error-budget policy↗

Canary under an error budget#

Compact instruction:

Run a partial, time-limited canary against a control; predeclare success and rollback metrics; cap cohort and duration by error-budget exposure; automatically promote or roll back.

This is much more specific than “test in production.” Google SRE canarying guidance↗

Blameless postmortem with closure#

Compact instruction:

Write a blameless postmortem covering impact, timeline, contributing system conditions, detection and response, and prevention actions with owners and due dates; review it and track actions to closure.

“Blameless” means investigating how the system shaped decisions, not omitting accountability or corrective work. Google SRE postmortem guidance↗

Chaos experiment with bounded blast radius#

Compact instruction:

Run a chaos experiment: define measurable steady state, state the hypothesis, inject one realistic fault, compare control and experiment, abort on guardrails, and minimize blast radius.

This is controlled hypothesis testing, not random breakage. Principles of Chaos Engineering↗

Game day#

Compact instruction:

Run a production-like game day using the real people, tools, runbooks, and escalation paths; record deviations and convert them into runbook or system changes.

The goal is organizational muscle memory and verified response capability. AWS game-day guidance↗

NALSD#

Compact instruction:

Apply Non-Abstract Large System Design: turn the whiteboard architecture into traffic, storage, compute, cost, scaling, overload, and failure-domain estimates with explicit assumptions.

This prevents an elegant diagram from hiding physical constraints. Google SRE NALSD guidance↗

Security and process controls#

STRIDE threat model#

Compact instruction:

Threat-model with STRIDE: draw data flows and trust boundaries; enumerate spoofing, tampering, repudiation, information disclosure, denial of service, and elevation-of-privilege threats; assign mitigations and verification tests.

This produces an actionable security model, not a generic “security review.” OWASP threat-modeling guidance↗

Abuse-case test matrix#

Compact instruction:

Build an abuse-case matrix: attacker goal, preconditions, attack path, expected denial or containment, observable evidence, and automated regression test.

For agents, include prompt override, tool misuse, privilege escalation, memory poisoning, exfiltration, runaway recursion, approval bypass, and multi-agent chaining. OWASP AI Agent Security↗

Least privilege + deny by default#

Compact instruction:

Apply least privilege and deny by default at every tool and object boundary; authorize every request in the acting user's context; test horizontal and vertical escalation.

This is much stronger than “be secure.” OWASP authorization guidance↗

Parameter-bound HITL approval#

Compact instruction:

Require a parameter-bound HITL gate for high-impact actions: show exact operation, target, arguments, side effects, and expiry; bind approval cryptographically or transactionally; reapprove any mutation.

This prevents a benign-looking approval from authorizing a different later action. OWASP AI Agent Security↗

Secure Software Development Framework (SSDF)#

Compact instruction:

Apply NIST SSDF: prepare the organization, protect software and build artifacts, produce well-secured releases, and operate a vulnerability-response loop.

The term invokes an outcome-based secure-development program rather than a one-time scan. NIST SSDF↗

DMAIC#

Compact instruction:

Run DMAIC: define the problem and customer requirement; measure a trustworthy baseline; analyze root causes; improve experimentally; control with monitoring and a reaction plan.

The Control phase is what keeps the work from becoming a temporary cleanup. ASQ DMAIC↗

FMEA#

Compact instruction:

Run an FMEA: enumerate failure modes, causes, effects, existing controls, severity, occurrence, and detectability; prioritize actions; reassess residual risk after mitigation.

This changes “consider what can go wrong” into a ranked failure-prevention process.

ASQ FMEA guidance↗

RTO / RPO / MTD#

Compact instruction:

Set MTD, RTO, and RPO per business capability; design recovery to those numbers; prove them with restore and failover exercises.

• MTD: maximum tolerable business-process outage;
• RTO: maximum acceptable time to restore the resource;
• RPO: maximum acceptable data-loss window.

NIST contingency-planning guidance↗

Words that sound precise but are not sufficient alone#

These should always receive a qualifier:

Compact command patterns worth adopting#

These combine Cory's language with researched control terms:

Run genetic agent-strategy evolution against explicit architectural fitness functions; retain champions, preserve lineage, and roll back any branch that regresses a protected function.

Use tree-and-leaves orchestration: ReAct leaves, branch-level self-consistency, Chain-of-Verification at the trunk, and independent SME scoring at the final gate.

Use hard-facts-first normalization with CRAG retrieval, source-level citations, epistemic labels, and a RAG triad evaluation before promotion.

Refactor by branch-by-abstraction behind a feature flag; prove parity with property-based, contract, and mutation tests; canary under the error budget; then remove the old path.

Apply STRIDE plus an abuse-case matrix; least privilege and deny-by-default; parameter-bound HITL for high-impact actions; retain validation evidence.

Run a NALSD pass, define quality-attribute scenarios and SLOs, add architectural fitness functions, then prove failure behavior through bounded chaos experiments and a game day.

Shareable statement#

My AI-development approach combines genetic strategy evolution, tree-and-leaves agent orchestration, bounded swarms, hybrid deterministic/LLM systems, deep tool-using RAG, simulation, and explicit evidence grading. I track “genetic wins,” promote successful agent strategies, retain previous winners, and remix them when later branches fail. Cheap leaf agents handle wide retrieval and execution; manager agents coordinate branches; the strongest model controls the trunk, architecture, supervision, and final synthesis. I use hard-facts-first normalization, best-guess deduplication without fact loss, Monte Carlo with tornado sensitivity analysis and transparent assumptions, and known/correlated/inferred/deduced evidence classes. I push toward full completion through truthful telemetry, final HIL gates, source-preserving checkpoints, and a “refactor, remix, or rethink” / “move and improve” standard.

Authorship and corpus boundary#

The authoritative baseline is the sanitized searchable release indexed by Full Projects History. Its capture receipt records:

• 15,657 conversations;
• 1,147,869 messages;
• 137,489 tool-activity records;
• 14,233 artifacts;
• 281 projects.

The phrase miner did not accept role=user at face value. It:

• limited Codex material to root tasks listed in inventory/codex-thread-metadata.tsv;
• removed duplicated message / user_message representations;
• stripped ambient browser, app, goal-continuation, approval, delegation, and subagent-notification wrappers;
• reopened Claude source records and retained only real user string or text blocks, excluding tool-result blocks;
• retained only the initial task block from Bob histories;
• normalized and exactly deduplicated candidate messages;
• copied no raw sessions into this repository.

At this snapshot, that process produced 1,657 distinct human-message candidates: 1,447 Codex, 208 Claude, and two Bob. Phrase-sized excerpts were then manually adjudicated for this report. The current live Codex archive was also checked for post-snapshot language; current-conversation additions, including the exact phrase “Monte Carlo simulation with tornado analysis,” are labeled by context rather than retroactively attributed to the older snapshot.

What is excluded#

• assistant answers and reasoning;
• tool calls and tool output;
• web, terminal, and file payloads stored under a user role;
• subagent prompts and completion notifications;
• generated task titles;
• environment, skill, browser, permission, and approval wrappers;
• project prose that appears only in generated artifacts;
• credentials, personal/legal evidence, URLs, emails, and full transcripts.

Project-document terminology may still prove that an approach existed in Cory's work, but it is not labeled as Cory's personal phrasing without direct-message evidence.

Reproducibility#

Run the read-only miner from the repository root:

node scripts/mine-human-language.mjs
node scripts/mine-human-language.mjs --query 'genetic|tree and leaves|Monte.?Carlo|RAG|deterministic'

The miner reads the sanitized history database and original source records in place and prints only aggregate counts or explicitly requested phrase-sized matches.