Human Edits Train the Models Built to Copy Them

Rami Alghodran’s September 6, 2026 essay argues that immutable software moats now live in human overrides, not in CRUD code. GitHub already trains Copilot on those same diffs for Free, Pro, and Pro+ users.

Alghodran, a senior software engineer and technical architect, published the piece on September 6 and updated it on September 7. He says specialized LLM agents have flattened boilerplate routes, schemas, and microservices, so platform value has to move into workflow context that models cannot guess.

A Levenshtein Score of 0.18

His proposed fix is a small TypeScript class, ContextMoatEngine, that compares a model’s default output with the version a person actually ships. It uses edit distance, then keeps a record when the gap is large.

The cutoff is a 0.18 normalized score. Below that, the human change is treated as noise. Above it, the engine logs a user id, a workflow id, the delta, and a timestamp, and prints that a proprietary loop has been “locked” for that flow.

The essay’s working split is familiar. Models handle the clean 80 percent of cases. People still mop up the messy 20 percent: tax anomalies, one-off compliance paths, the override that never made it into the spec. Alghodran wants that residue stored as “behavioral dark data” through a human-in-the-loop capture path.

He also points past code. Sticky daily workflows, he writes, create switching cost that a generated clone cannot buy. Granular compliance logs and SOC 2-style guardrails take years to audit, so trust becomes part of the wall. The diagnosis is sharp. The sample engine is a local EventEmitter with a console line. That is not how the flywheel already runs in production editors.

GitHub Trains Next-Edit Models on Live Sessions

GitHub’s Copilot team learned the same lesson the hard way, and then industrialised it. Next edit suggestions, a custom in-editor model, launched in February 2025. A November 20, 2025 engineering post, updated November 25, says pull-request diffs were the first training idea and a bad one.

PRs show the finished patch, not the abandoned rewrite, the pause, or the choice to touch nothing. Internal tests made the model timid. It lagged a plain LLM. So the team collected live editing sessions from volunteers, then fine-tuned, then used reinforcement learning so the grader could mark a suggestion as unhelpful, not only as correct.

The hard part wasn’t the architecture; it was the data. We needed a model that could predict the next edit a developer might make, but no existing dataset captured real-time editing behavior.

GitHub Copilot applied science team, GitHub Blog, November 20, 2025

That sentence is the whole joke around shift-left defensibility. The “un-guessable” human step is exactly the label you need once you want a model to take the next step for you. GitHub said there was no existing dataset captured real-time editing, then it built one from people working in the editor.

THE NEXT-EDIT SCOREBOARD

GitHub reports those figures from A/B tests against production. The May and November drops in shown rate were intentional. Early users said the model jumped in too often, so the team added more “do not edit” samples and raised the bar for a visible suggestion. Acceptance still climbed. Hide rate fell. The product got quieter and stickier at the same time, which is what a context flywheel looks like when a vendor owns the loop.

THE SHIFT-LEFT TIMELINE

1. February 2025: GitHub ships next edit suggestions as a custom Copilot model beside the cursor.
2. November 20, 2025: The team describes volunteer edit-session data, supervised fine-tuning, and reinforcement learning on unlabeled code.
3. March 25, 2026: GitHub chief product officer Mario Rodriguez announces a new default for personal Copilot plans.
4. April 24, 2026: Interaction data from Copilot Free, Pro, and Pro+ begins feeding model training unless the user opts out.
5. September 6, 2026: Alghodran publishes the ContextMoatEngine pattern as an architectural response to generated CRUD.

By the time the essay landed, the highest-volume version of its engine had been running on personal Copilot seats for more than four months.

Who Owns the Override Once It Is Logged?

Once a human change is stored as structured telemetry, ownership follows the pipe, not the intent of the logger. GitHub trains on accepted and modified Copilot output for Free, Pro, and Pro+ unless the user opts out. Cursor may train on editor actions when Privacy Mode is off. Palantir and Celonis try to keep the same class of judgment in a graph the customer runs.

Rodriguez’s March 25 note is blunt about the personal-plan default that took effect on April 24, 2026. GitHub said it had already seen better acceptance rates after training on Microsoft employee interaction data, and it wanted a wider mix of real workflows. Copilot Business, Copilot Enterprise, and enterprise-owned repositories are carved out. Users who had already switched off collection for product improvements keep that choice.

The training corpus, when you stay in, is not a vague “usage metric.” GitHub lists outputs accepted or modified by you, inputs and snippets shown to the model, cursor context, comments and docs, file names and repo shape, navigation, chat and inline use, and thumbs up or down. Private repos at rest are out of scope. Code Copilot sees while you work can still go into training if you have not opted out.

Cursor’s own data-use page, updated August 28, 2026, inverts the default if you turn the right switch. Privacy Mode stops vendor training and pairs it with zero-data-retention deals with model providers. Leave that mode off, and Cursor says it may store codebase data, prompts, editor actions, snippets, and other code actions to improve features and train models. The override is still a human edit. The question is which company gets to keep the pair.

WHERE THE DIFF GOES

On personal seats, Alghodran’s 0.18 gap is not a secret sauce. It is a training label. Developers who care already hunt for the opt-out instead of trusting a long policy. That is a reasonable habit. It is also a reminder that a local log line does not decide who learns from the edit if the edit happened inside a hosted agent.

Palantir Maps the Nouns and Verbs of Work

Enterprise software already has a thicker version of the same idea, and it does not look like a diff score. Palantir’s documentation calls the Ontology an operational layer for the organization. Datasets, tables, and models get tied to plants, orders, equipment, and other real objects, then to the actions those objects are allowed to take.

The Ontology sits on top of the digital assets integrated into the Palantir platform and connects them to their real-world counterparts, ranging from physical assets like plants, equipment, and products to concepts like customer orders or financial transactions.

Palantir Foundry documentation, Ontology overview

Objects, properties, and links are the nouns. Action types and functions are the verbs, written so a change still obeys the firm’s controls. Security is not a wrap-on policy doc. It is modeled with the objects, so a human analyst and an agent query the same graph under the same permissions. Palantir’s architecture notes describe that graph as the language of operational processes for both people and agents, with an engine that queries huge object sets and folds feedback back in.

That is HITL capture with a budget and a security model. A tax anomaly is not a string distance. It is an action on an object, with a who, a when, and a rule. If the graph stays inside the customer’s deployment, the 20 percent does not have to become someone else’s fine-tune. If the same exception is typed into a personal Copilot chat, it can.

Exceptions That Used to Live in Slack Threads

Celonis is selling the operational twin from the process-mining side. Its product blog introduces a Context Model built on the Process Intelligence Graph, and it ties that launch to a deal to acquire Ikigai Labs for decision intelligence. The pitch matches Alghodran’s 20 percent, only the unit of record is an invoice path, not a code hunk.

AI models don’t know about how your specific invoices are related to your shipping records because that data is proprietary, private, and fragmented across internal systems, applications and devices.

Celonis product blog, The Context Model

The same post cites Jaya Gupta and Ashu Garg of Foundation Capital on a “context graph”: a structured record of how a given firm actually decides, including the exceptions, overrides, and precedents that still live in Slack and in people’s heads. Celonis says a context model has to add a world-model layer on top of that history so agents can simulate what happens next, not only replay what happened.

WHAT CELONIS SAYS THE LAYER MUST BE

• Process-centric: Agents see the sequence of steps, decisions, and exceptions, not a pile of tables.
• System-agnostic: The graph is meant to travel across ERPs and agent vendors instead of sitting in one app silo.
• Dynamic: New processes are mined as they run, and the model learns from people and agents in real time.
• Open: APIs and MCP hooks are the escape hatch Celonis offers so the context can outlive a single model vendor.
• Trusted: The claim is deterministic ground truth, so an agent can act in a live operation without guessing the happy path.

Celonis also says the store compounds. Each human or agent pass feeds the model, and the company calls that the rare AI asset that gains value with use even if you swap the underlying model. Read that next to GitHub’s NES table and the pattern repeats. Capture the exception, grade it, train, reduce noise, raise acceptance. The difference is whether the compounding happens on your process graph or on a coding agent’s weights.

Open-source copies of the Palantir-style graph are already circulating as self-hosted agent memory, with provenance and decision replay as the selling points. Category language got cheap fast. That does not make a 15-year process graph free to rebuild. It does mean “we logged the override” is no longer a scarce trick.

Keep the Judgment Off the Training Pipe

Gupta, who helped popularise the context-graph framing, posted a long follow-up on May 8, 2026 that moved the scarce layer again. Interfaces converge. Product velocity gets cheap. Startups rename themselves every few months around context graphs, systems of action, world models. The hard copy, she argued, is the institution: how a firm concentrates judgment and turns work into a system another company cannot staff.

The shape of the company itself is becoming the moat.

Jaya Gupta, Foundation Capital, May 8, 2026

That line sits cleanly on Alghodran’s closing list. Invisible workflow habit still belongs to the operator who lives in the tool. SOC 2-style evidence still belongs to the team that sat through the audit. A 0.18 score written to stdout belongs to whoever can read the stream. If that stream is a personal Copilot session, GitHub has said it will use the modification unless you opt out. If it is an action on an object inside a customer-controlled ontology, the exception can stay a firm asset.

The practical split is dull, which is why it holds. Use the Copilot tier that is excluded from the April 24 training program, or switch the privacy control off the default. Turn Cursor’s Privacy Mode on if the repo should not teach the vendor. Put tax anomalies and other one-off calls into a graph with permissions, not into a chat pane. Log human overrides if you want, but treat the log as sensitive training data, because that is what the last two years of editor models were starved for, and what they were built to eat.