←
AI-Ready Foundation
Visionary · M5 · lesson 5 of 5 · queued
Preview — browse every lesson free. Enroll to mark lessons complete, open partner links and save your progress. Login & enroll →
The Data Flywheel: Turning Proprietary Data and Feedback Loops into Durable Advantage
📖
now learning

The Data Flywheel: Turning Proprietary Data and Feedback Loops into Durable Advantage

15 min

Cursor's code-completion model, Tab, learns from a signal most companies throw away: every accepted or ignored suggestion goes back into training, and a new version ships every couple of hours, by the company's own account. That is a data flywheel: a loop in which every use of an AI system produces a signal about whether it was right, the signal improves the system, and the improved system gets used more. Your people produce the same signal whenever they accept, edit or override AI output. This lesson shows you how to capture it with the rights to keep it, turn it into a versioned evaluation set, choose honestly between retrieval and fine-tuning, and run a three-hour session that ends with a Feedback Loop Canvas and your first Eval Set.

You are at Level 5, AI Native, lesson 3 of 5. In Lesson 22 on governed autonomy, agent identity and kill switches you gave every agent an identity, an owner and an off-switch, and wrote them into an Agent Register. Its logs of approvals and overrides are your raw material. In Lesson 24 on continuous AI assurance and audit-ready evidence you will wire the eval set you build here into a pipeline that runs on every change and keeps audit evidence.

The Problem: AI That Never Learns Costs You Twice

How did Cursor turn accept and reject into a learning loop?

Cursor treats every accepted or ignored code suggestion as a training signal, and retrains and redeploys every couple of hours. The Cursor blog post of 12 September 2025 describes how. It is the company's own account, not independently verified, so treat the numbers as vendor-reported.

Tab handles over 400 million requests per day, the post says. Each ends with the suggestion accepted or ignored, a quality signal that arrives free, inside the work, with no survey.

Cursor feeds that signal into online reinforcement learning: the model is rewarded when a suggestion is accepted and penalized when it is not, so it drifts toward the behaviour that earns acceptance. A new checkpoint is rolled out and the data for the next training step collected in 1.5 to 2 hours.

The reported result is worth reading twice: 21% fewer suggestions, with a 28% higher accept rate. The model got better not by saying more but by learning when to stay quiet. Expect the same: much of your improvement can be the system learning what it should not answer alone.

What does it look like when nobody keeps the signal?

Now picture an illustrative pump manufacturer. A technician asks the service assistant whether a seal replacement is under warranty. The answer cites a bulletin engineering replaced months ago, so she rewrites it before it goes out: the fortieth such fix since the bulletin changed.

Her corrected answer is saved to the case; the link between what the assistant said, what she changed and why is saved nowhere. So the assistant repeats the mistake the following week, and so does the better model you switch to a year later. Your competitors rent the same model; the only thing that could make yours better is those forty corrections, and you threw them away.

What does an AI system that never learns cost?

Twice: once in errors you keep paying for, and again in an advantage you never build.

The MIT NANDA "GenAI Divide" report (August 2025, summarized by GovInfoSecurity on 4 September 2025) names a "learning gap" as the main reason enterprise pilots stall: most systems do not retain memory, adapt to feedback or fit the workflow. The headline figure, that about 95% of enterprise generative-AI pilots produced no measurable P&L return, is disputed and is available here only through a press summary, so keep it out of your steering committee pack. The diagnosis is what matters.

Nor do errors vanish because the system reads your documents. Lesson 7 on why naive RAG retrieval fails walked through the Stanford study of May 2024 in which specialist legal research tools built on retrieval still hallucinated 17 to 33% of the time. "It cites sources" is not "it is right".

The second cost never appears on an invoice. On the same model as your rival, the only durable difference is what your system learns from your own outcomes. Discard them and you have chosen to be average.

One honest caution: no rigorous public study has been found proving that an enterprise data flywheel creates lasting advantage. Cursor is a product example, so "durable advantage" is a hypothesis to test on a fixed evaluation set, not a promise for the board.

What does Cursor teach, and what does it not?

The four parts of any flywheel:

  1. An outcome signal captured inside the workflow, with its context, when it happens.
  2. A pipeline that turns the signal into evaluation and training data.
  3. A short redeploy cycle, so the loop keeps turning.
  4. A metric that shows the loop tightening: accept rate up, suggestion count down.

What it does not give you is a cadence. Cursor has enormous volume and a binary signal; your service desk has hundreds of interactions a day and a messier one, such as half an answer edited or an approval reversed a week later. Most enterprises will run the loop weekly or monthly.

Your competitors can rent the same model. They cannot rent a year of your experts' corrections, unless you throw them away.

How a Data Flywheel Works: The Coach Who Watches the Match Video

Picture two clubs in one league, with the same kit supplier and the same transfer market.

At the first club, the match video is recorded and filed. Nobody watches it.

At the second, the coach sits down every Monday with Saturday's footage. She tags every misplaced pass and broken set piece, files each clip with a one-word reason (position, timing, communication), and sets the week's drills from the tags. Each month she reruns the benchmark drills from August, timed the same way, so she knows whether the team is improving or just feels like it.

After a season the second club plays noticeably better, and no rival can copy that by buying the same kit.

  • The kit supplier is your model vendor, and the kit is the base model: identical for every club.
  • The match footage is your accepts, edits, overrides and complaints.
  • The tagged clip library is the capture record, with its reason codes.
  • The benchmark drills are the evaluation set: the same test, run the same way, every time.
  • The Monday session is your loop cadence: re-score, fix, redeploy.

Notice two things. The coach works from footage that was being recorded anyway, as your signals already exist in the workflow. And some of what she learns is not about the players: if every attack down the left dies in the same waterlogged corner, the fix is the drainage, not a drill.

What is a data flywheel in AI?

A data flywheel in AI is a loop where each use produces a signal about whether the output was right, the signal improves the system, and the better system gets used more. The first turns are heavy; momentum comes only if you push on a schedule.

You will also hear "data moat": the claim that proprietary data protects you from competitors. It is a slogan until quality on a fixed test rises because of your data.

The three building blocks: retrieval, fine-tuning and the evaluation set

  • Retrieval means fetching your documents at question time and handing them to the model, so it answers from your material (retrieval-augmented generation, or RAG, from Lesson 7).
  • Fine-tuning means further training a model on your own examples so a behaviour is built in rather than explained every time.
  • An evaluation set (eval set) is a fixed, versioned list of real questions with expert-approved answers, used to score any model or prompt the same way every time. If you built a golden test set in Lesson 8 on LLM evaluation and golden test sets, this is its grown-up form: one that keeps growing from live corrections.

On the training ground, retrieval is checking the tactics board before a set piece, fine-tuning is drilling the move until nobody needs the board, and the eval set is the benchmark drills.

RAG vs fine-tuning: when should you fine-tune instead of using retrieval?

Use retrieval when knowledge changes often, must be cited, or must respect who may see what. Add fine-tuning, or a small specialised model, for a stable behaviour, format, tone, speed or unit cost, once you own enough labelled outcomes to teach it. Keep retrieval alongside, and build the eval set before either: it is the only way to know whether anything helped.

Retrieval wins on change, citation and permission. If warranty terms change every quarter, the model should read the current version, not carry last quarter's in its weights. Retrieval can show an auditor the source and hide the pricing file from a technician; a fine-tuned model cannot forget its training for one user and remember it for another.

Fine-tuning wins on stable behaviour and economics. House format, tone, sub-second response or a lower cost per call are behaviours, not facts, and behaviours are what training builds in. Teaching them takes labelled outcomes, which is exactly what the flywheel produces.

They are layers, not rivals. Microsoft Research's "RAG vs Fine-tuning" case study on agriculture (January 2024) found fine-tuning raised accuracy by over 6 percentage points and retrieval added about 5 more on top; in one experiment answer similarity rose from 47% to 72%. It used older models in one domain, with no 2026 replication found, so take the shape, not the numbers: both beat either. Open-weight models that firms host and train themselves also put fine-tuning within reach; Lesson 25 covers that evidence.

Why is the eval set, not the model, the asset you keep?

Because fine-tuned weights are tied to a base model that will be retired, while an eval set and its labelled outcomes carry over to whatever model comes next. Anthropic's model deprecations page (as logged through September 2026), for example, promises at least 60 days' notice before a public model is retired, and Lesson 25 on avoiding model lock-in shows how often that notice arrives. When the base model goes, a fine-tune built on it goes too.

What survives is what you used to build and judge it: the captured corrections, the labels and, above all, the eval set. In your own store, they let you qualify a replacement quickly and retrain if the test says so. The coach who leaves takes her eye with her; the clip library and the benchmark drills stay at the club.

What does expert grading look like in a real enterprise?

It looks like an expert grading outputs against a standard, the enterprise version of Cursor's accept and reject. Lesson 18 covers Morgan Stanley in full (OpenAI's undated customer story, a vendor source); the point here is that it did not wait for millions of clicks but spent scarce expert time on grading and turned it into a daily regression test, a low-volume, high-stakes flywheel.

Should the feedback loop improve only the model?

No. The best loops also improve the organization around the model. In an UNLEASH interview on Moderna, the company describes an "Ask HR" router GPT that sends each question to a specialist GPT, with recurring questions analysed to change policy and communication. That is the waterlogged corner: many corrections point at a stale document or a broken process step, and a flywheel that only retrains the model learns to work around faults an owner could simply fix.

Who owns the feedback data, and may you keep it?

Not automatically you. Settle three questions in writing before you capture a single correction, because each can switch the flywheel off later.

1. Can your vendor train on it? If your provider may train on your prompts, outputs and feedback, your experts' corrections improve a model your competitors rent. Terms differ by tier, not just by vendor. In Anthropic's consumer terms update of 28 August 2025, Free, Pro and Max users were asked to choose whether their chats could train models (kept five years if they agreed), while Commercial Terms services, including the API and Claude for Work, were excluded. Check your contract's data-use clause for inputs, outputs, ratings and edits, and keep experts off personal accounts the contract does not cover.

2. Is reuse compatible with why you collected it? Reusing interactions collected to answer customers as eval or training data is further processing. The GDPR's purpose limitation principle (Article 5(1)(b), Regulation (EU) 2016/679) says personal data must be "collected for specified, explicit and legitimate purposes" and "not further processed in a manner that is incompatible with those purposes". Article 6(4) weighs the link between purposes, the context of collection, the nature of the data, the consequences for people, and safeguards such as pseudonymisation. So masking names before cases enter the eval set is part of your legal case, not hygiene. Plan on today's text: the Commission's November 2025 digital omnibus proposal would have made legitimate interest an explicit basis for AI training, the Council text of 21 October 2026 removed it, and talks with Parliament are not expected before March 2027, reports Addleshaw Goddard on 26 October 2026.

3. Does logging edits monitor named employees? A log of who edited what is a record of individual performance. In Germany the works council has co-determination over "the introduction and use of technical devices designed to monitor the behaviour or performance of the employees" under section 87(1) no. 6 of the Works Constitution Act, and without agreement a conciliation committee decides. If the system is high-risk under the EU AI Act (Annex III duties apply from 2 December 2027), Article 26(7) also requires employers to inform workers' representatives and affected workers before workplace use. Elsewhere, ask employment counsel. Everywhere, record the editor's role and a pseudonymous ID rather than a name, rule out individual appraisal in writing, and sign before capture goes live.

A flywheel built on data you may not keep is switched off the day someone notices.

The Workshop: Run a Feedback Loop Design Session and Build Eval Set v1

This three-hour working session fits in three hours only because the slow work happens the week before. You leave with a one-page Feedback Loop Canvas for one workflow and Eval Set v1, a versioned file of 50 real cases with expert-approved answers. Of the seven steps, only Step 4's retrieval fix waits for the following week.

Who needs to be in the room, and for how long?

The session is built around the experts' scarce time.

  • Three domain experts who correct the AI's output daily, through Step 4, with time protected by their line manager.
  • The process owner, who owns the outcome and chairs.
  • A data engineer, who prepared the cases and builds the capture record.
  • The AI platform lead, who runs the scoring script.
  • The agent owner named in your Lesson 22 Agent Register.
  • The privacy or data-governance partner, for the first twenty minutes only.

What pre-work makes three hours enough?

Budget about a day of effort the week before; without it, 50 cases in one sitting is fiction.

  • Rights cleared. The privacy partner answers the three data-rights questions. Without works council agreement you can still build the eval set from masked historical cases, but capture waits.
  • Cases selected and masked. The data engineer pulls recent cases from the Agent Register logs where a human changed the AI's output, pre-selects 60 (ten spares for cases the experts reject) and masks them as agreed.
  • Drafts pre-filled. For each case, the human's final version and its cited source go in as a draft expected answer, so experts confirm or correct rather than write from a blank page. That is what makes about 90 seconds a case realistic.
  • Scoring script ready. The platform lead dry-runs a script that sends the case file to the production configuration (read-only) and writes each answer and its sources into a grading sheet.
  • Context to hand. The data classification from Lesson 2 and the quality metrics from your Lesson 21 redesign.

How do the three hours break down?

TimeStepWho must be thereOutput
0:00 to 0:201. Signals and capture recordEveryone, including privacyTwo signals, record fields, rights line
0:20 to 1:452. Build Eval Set v1Experts, data engineer, process owner50 agreed cases with sources
1:45 to 1:55Break while the scoring run completesPlatform leadGrading sheet of live answers
1:55 to 2:253. Score the current systemExperts, splitting the 50Baseline accuracy and unsupported-claim rate
2:25 to 2:404. Diagnose failures, assign the retrieval fixExperts, platform lead, data engineerFailures by reason code; fix owner and date
2:40 to 3:005 to 7. Fine-tuning test, cadence, routingProcess owner, platform lead, agent ownerCompleted canvas

Check the arithmetic. Step 2 gives 85 minutes for 50 cases: two experts confirm each draft side by side at about 90 seconds a case, and the third arbitrates disagreements. Step 3 is quicker, since grading against an agreed answer beats agreeing it: about 17 answers each.

The worked example we will follow

Illustrative only: the 600-person pump manufacturer from the opening, whose assistant answers technicians' warranty and fault-code questions. A technician can send the answer, edit it, or escalate to a senior engineer.

Step 1: Choose the signals and agree the capture record

List every outcome event the workflow produces (accept, edit, override, escalation, complaint) and pick the two most frequent and most honest. "Honest" means it reflects quality, not convenience: a hurried accept tells you less than an edit. The pump firm finds four (accepts, edits, overrides buried in email, re-contacts unlinked in the CRM) and picks edits, which are frequent, and overrides, which are rare but carry the senior engineer's correct answer.

Then agree the record every event will write: the input; the retrieved sources, by document and version; the model and prompt version; the AI's output; the human's final version; a reason code from a short, fixed list; the agent identity; the editor's role and pseudonymous ID; and a timestamp. A signal without context is a clip with no tag. The pump firm settles on five reason codes: wrong part, outdated bulletin, wrong warranty term, tone, other.

The privacy partner then reads the pre-work decisions onto the canvas. For the pump firm: the contract excludes training on inputs, outputs and feedback; names are masked; the works council has agreed the record, provided it is never used for individual appraisal.

Step 2: Build Eval Set v1 in the room

This is the heart of the session, and it happens now, not "after we have the pipeline". For each pre-filled case, two experts confirm or correct the expected answer and its source. Where they disagree, the third decides, and the disagreement can reveal a rule nobody has written down. Drop ambiguous cases; that is what the spares are for.

It is an evaluation set first and training data second. Name and version it, and store it in your own repository, not a vendor's tool.

FieldWhat goes in itPump firm example (illustrative)
InputThe real question, masked as agreed"Fault code E14 on a 2023 unit, is the seal replacement covered?"
Expected answerThe answer the experts agreed"Covered for 24 months from commissioning; check the date on the unit plate."
SourceThe governed document and versionWarranty terms, current version, section on seals
GraderWho approved it, and whenGrader ID of a senior service engineer, workshop date

Step 3: Score the current system to get a baseline

The scoring script has already run Eval Set v1 against production. The experts grade the answers and record two numbers: answer accuracy (cases judged correct) and unsupported-claim rate (answers containing a statement no retrieved document backs up). Teams skip the second; the Stanford result is why it matters. The pump firm's baseline: 31 of 50 correct, and 9 answers with an unsupported claim.

Step 4: Fix retrieval first

Before anyone mentions training, sort the failures by reason code and check what the system reads: governed sources with named owners, permissions respected, superseded documents retired. Lesson 6 on fixing data quality one use case at a time gave you the tests for owned, current, single-versioned sources; this is where they pay off. In the room you diagnose and assign. The fix and the re-score are the first task of the following week, because changing a production index goes through normal change control.

The pump firm's reason codes made it obvious: 11 of its 19 failures cited a service bulletin that had been superseded but never removed from the knowledge base. The fix is a retirement rule: when a new bulletin is issued, the old one leaves the index the same day. That is a process change, not an AI change.

Step 5: Apply the fine-tuning test

Plan fine-tuning, or a small specialised model, only if both are true: a stable skill, format, tone, latency or unit-cost target is not being met by prompting and retrieval, and you own enough labelled outcomes to teach and test it. Then check when the base model retires; if you do not know, or it falls inside the payback period, do not start. If you do, keep retrieval alongside. The pump firm writes "No fine-tuning yet": failures come from stale sources, and labels are still too few. It sets a review once capture has run for a quarter.

Step 6: Set the cadence, name the operator and keep the assets portable

Schedule adding corrections to the eval set, re-scoring and redeploying; weekly or monthly suits most workflows. Name the operator, because an unowned loop stops on the first busy week, and protect the experts' time: the pump firm's service manager books 30 minutes a week per expert as a recurring slot, not a favour. Then write where the data, labels and eval set live: your own stores, in a plain, vendor-neutral format such as rows in a table. Any fine-tuned weights are rebuilt on the successor. The eval set is the asset; weights are a by-product.

Step 7: Route recurring errors to the process owner

Each cycle, list the top five recurring corrections, sort model problems from policy, document or process problems, and send the second kind to its owner. The pump firm's first list: the superseded bulletin (engineering documentation), a warranty clause technicians read two ways (commercial), and a fault code missing from the manual (product engineering). None is a model problem.

The artifact: your Feedback Loop Canvas

Copy this template; the right-hand column is the pump firm's illustrative canvas.

Canvas fieldWhat to writePump firm example (illustrative)
Workflow and ownerOne workflow, one accountable ownerService desk warranty answers; Head of Service
Outcome signals chosenThe two most honest, frequent signalsTechnician edit; senior engineer override
Capture record and locationFields and storage locationNine fields, service data store
Data rights and retentionVendor clause, purpose compatibility, employee consultation, retentionNo vendor training; names masked; works council agreed, no appraisal use
Eval set name, version, size, rubricIdentifier, version, size, what counts as correctService Desk Eval Set v1, 50 cases; part, term and source all right
Expert graders and weekly timeGrader IDs and protected timeThree senior technicians, 30 minutes a week each
Baseline scoresAccuracy and unsupported-claim rate31 of 50 correct; 9 unsupported claims
Retrieval sources and ownersEach governed source and its ownerWarranty terms (commercial); bulletins (engineering documentation)
Fine-tuning decision and reasonYes or no, and whyNo: failures are stale sources; too few labels so far
Loop cadence and operatorSchedule and named personMonthly re-score and release; AI platform lead
Portability statementWhere data, labels and evals liveOwn repository, plain tables; no vendor-only storage
Process-feedback list and recipientTop recurring issues and recipientsBulletin, ambiguous clause, missing fault code; each to its owner

Your second deliverable is Eval Set v1 itself. Put both in one folder for your next steering committee: when someone asks "is our AI getting better?", you can now answer honestly.

Failure Modes, How to Spot Them, and the Metrics to Track

Seven failure modes explain most flywheels that never turn, or turn and are then stopped.

Failure modeHow to spot it
No feedback captureYou cannot produce last quarter's overrides with their reasons
Capture built before rights are clearedNobody can show the vendor training clause or works council agreement
Retrieval assumed to be truthNo unsupported-claim rate is measured; "it cites sources" is offered as proof
Fine-tuning on a model about to retireThe base model's retirement date is unknown or inside the payback period
Unmeasured "data moat"No fixed eval set, so no release-over-release score exists
Feedback never reaches process ownersThe same correction reason tops the list three cycles in a row
Graders have no timeThe eval set has not grown since the workshop

Three deserve a word. The "data moat" failure is the most expensive, because it sounds like strategy: if a board paper calls your data a competitive advantage, ask for the eval set score at the last three releases. No score, no moat. The rights failure is the most sudden: one unanswered question from a works council, data protection officer or procurement review stops capture overnight. The grader-time failure is the quietest: nothing breaks, the loop just stops. If the eval set's version has not moved in a month, nobody is grading.

Which metrics show the flywheel is turning?

Five, measured on the same workflow over time.

MetricHow to measure it
Acceptance rateAccepted outputs divided by outputs shown, per week
Edit distance or override rateHow much humans change the output, and how often an approver reverses it
Eval set score trendSame versioned set, scored at every release, plotted over time
Time from feedback to deployed improvementDays from a logged correction to a release that passes the case
Share of interactions producing usable labelsInteractions with captured outcome and context, over all interactions

No public benchmark gives target values, so set targets from your own baseline; the direction of the line matters more than its height. Remember Cursor: a rising acceptance rate on fewer outputs can mean a better system, so read it with the eval set score, never alone. Once the set grows every cycle, it is worth automating, which is where Lesson 24 picks it up.

Frequently Asked Questions

Can our AI vendor train on our users' corrections?

Only if your terms allow it, and terms differ by product tier, so check the exact plan your people use. Anthropic's 28 August 2025 update, for example, asked consumer users to choose whether their chats could train models, while excluding the API and other commercial services; read your contract's clause on inputs, outputs and feedback, and keep experts off personal accounts.

How many cases do we need to start an evaluation set?

Fifty real cases with expert-approved answers and sources are enough to start. Three experts can agree them in about 85 minutes when drafts are pre-filled, and the set is large enough to show whether a change moved the score; grow it every cycle.

Does retrieval-augmented generation stop hallucinations?

No. A May 2024 Stanford study found commercial legal research tools built on retrieval still hallucinated 17 to 33% of the time, so measure the unsupported-claim rate yourself on your own eval set.

Do we need works council approval to log employees' edits to AI output?

In Germany, assume yes if the record shows who edited what: section 87(1) no. 6 of the Works Constitution Act gives the works council co-determination over technical devices designed to monitor employee behaviour or performance. Agree the record before capture goes live, store a role and pseudonymous ID instead of a name, and rule out appraisal use in writing.

Is proprietary data really a competitive moat for AI?

Not automatically. No rigorous public study has been found proving that an enterprise data flywheel creates lasting advantage, so treat the moat as a hypothesis and prove it with a rising score on a fixed eval set, release after release.

Key Takeaways

  • A data flywheel has four parts: an outcome signal captured in the workflow, a pipeline into eval and training data, a short redeploy cycle, and a metric showing the loop tightening.
  • You already produce the signal. Capture edits and overrides with input, sources, versions, final answer and reason code.
  • Clear the rights first: the vendor's training clause, GDPR purpose compatibility, and works council consultation where edits are logged per person.
  • Build the eval set first. Fifty expert-approved cases in your own repository are enough to start, and a week of pre-work makes them buildable in one session.
  • Retrieval does not remove hallucination. Measure the unsupported-claim rate, and fix your sources before you train anything.
  • Retrieval and fine-tuning are layers, not rivals. Fine-tune only for a stable behaviour or cost target with enough labels, never on a base model about to retire.
  • The eval set is the durable asset and "data moat" is a hypothesis: prove it with a rising score, and route recurring corrections to process owners.