Coding got a feedback loop. Knowledge work didn’t.
The real reason why AI is eating software but stalling on knowledge work.
For about two years, the standard explanation for why AI ate software but barely touched knowledge work was access. Developers lived in a terminal and everyone else didn’t, so the reasoning went that if you put the same agent in front of a diligence analyst or a lawyer or a financial modeler, in something they’d actually open, you’d get the same explosion in output.
That explanation died this year.
The frontier coding harnesses each grew a friendly desktop app. Anthropic took Claude Code’s engine and dropped it into Claude Cowork. OpenAI shipped the Codex desktop app and called it a command center for agents. And Microsoft, with Copilot Cowork, went a step further and built something aimed squarely at knowledge workers rather than developers, now generally available worldwide with more than half the Fortune 500 reportedly already touching it. The friendly interface everyone said was missing is here now, in several flavors. Whatever was holding knowledge work back has had its excuse taken away.
It still hasn’t had its moment, not the way coding did. And that tells you the interface was never the thing. If access had been the real constraint, the impact would have shown up the moment the terminal disappeared, and it didn’t. So the constraint sits lower down, and I’ve come to think it’s this: coding came with a feedback loop built in, and knowledge work has never had one. The model was never what was holding this back. The loop was.
Starting with code was the right call
I want to be careful here, because the lazy version of this argument is “the labs bet on the wrong thing,” and that’s not what I believe.
Starting with code was correct. Code is where a cheap, fast feedback loop already existed, so it’s exactly where an agentic harness should have been born. And the labs have been clear that this is a progression and not a finished story.
So the interesting question isn’t whether they sequenced it right. Which I think they did. It’s which parts of the harness were quietly leaning on properties that code has and most knowledge work doesn’t.
Because here’s what’s easy to miss when these all land at once looking like fresh products. Cowork is Claude Code’s engine in a window. Codex desktop reads your existing CLI config and picks up where it left off. Those are extensions of the coding harness, not a rethink of it, and that matters because the coding harness was built on top of something knowledge work can’t supply.
Code’s real gift was never raw intelligence. It was an oracle that’s cheap and instant. You write something, you run it, and within a second the world tells you whether you were wrong, in the form of a compile error or a failing test or a stack trace pointing at the exact line. The whole loop of generate, run, observe, fix assumes that oracle is sitting there. The new UX changed the surface. They didn’t change the assumption that something is standing by to grade the work.
Knowledge work fails by omission, and you can’t test a silence
Knowledge work has no oracle.
There’s no command that tells you whether a diligence report caught every material risk. Nothing turns green when a memo is complete and red when it quietly missed the one liability buried in a side letter. You can’t write an assertion for “did this consider the thing nobody thought to look for.”
This is the part I keep coming back to, because it’s the whole crux. The dominant way knowledge work fails is by omission, and you cannot catch an omission by reading what’s on the page. A bad line of code announces itself, loudly and immediately, at a specific location. A missing risk announces nothing. It sits inside a document that reads cleanly and well, and it surfaces months later when a deal goes sideways and somebody asks how nobody flagged it.
There’s a particularly nasty version of this that’s specific to AI work. These systems are fluent, which means they produce output that sounds authoritative whether or not the evidence underneath supports it. A report claims an interview that never happened. A figure carries a suspiciously precise number attributed to a named authority that can’t be traced. The hard analysis gets quietly deferred behind a sentence that says it “should be examined further.” None of that trips an error. It reads beautifully. Of course, you can push models to perform self-review, but much of that review is really omission-detection, and reading a large corpus of documents naively is not free.
That single asymmetry wrecks the economics that make coding agents worth it. With code, accepting a suggestion is cheap next to writing it yourself, because you can glance at it, run the tests, and move on. In serious knowledge work the checking costs about what the doing costs, because the only way to know what’s missing is to already know, independently, what should have been there. Once verification costs roughly what production costs, the productivity case quietly falls apart.
Then there’s liability, which the coding analogy never has to carry. In a regulated diligence or legal setting a person puts their name on the output, and the question stops being “is this good” and becomes “am I willing to stake my reputation on it,” which no citation footnote clears by itself. Even when the model cites everything, someone still has to open each source and confirm it says what the model claimed. This is the real shift underneath all the productivity talk: as AI makes production cheap and abundant, the scarce thing isn’t the output anymore, it’s the judgment and the willingness to stand behind it. Production gets cheaper. Accountability gets more expensive.
The inputs don’t sit still, and half of them aren’t written down
Say you tried to just give the agent everything it needs. You run into two different walls, and they’re worth separating.
The first is knowledge that exists but doesn’t retrieve cleanly. Retrieval is great when the job is lookup, find the clause, pull the number. It struggles the moment the job is reconciliation, three sources that disagree and the real work is the synthesis that settles them. Retrieval hands you fragments and leaves the reasoning across them to you. You can push back on this with proper structure, graphs that capture how things actually connect rather than a flat pile of chunks, but most teams can’t build those, and most engineers badly underestimate how much hidden structure ordinary knowledge work carries.
Get Arsalan Pardesi’s stories in your inbox
Join Medium for free to get updates from this writer.
This first wall is exactly the one Microsoft is attacking with Copilot Cowork, and credit where it’s due, this is the most serious attempt of the bunch. It isn’t a repackaged coding harness. It’s built on Work IQ, a layer that grounds tasks in your real emails, meetings, files, and business data instead of making the model guess. That’s the right idea and a genuinely hard thing to ship. But look at where its knowledge actually comes from, and the shape of the limit appears. Cowork sees what’s indexed in the Microsoft Graph, and Microsoft is candid about what that means: if a user can’t find something through Microsoft Search, Copilot can’t surface or use it either. So the boundary of the agent’s world is the boundary of the index, and not just its coverage but its quality. Grounding is only ever as good as the retrieval underneath it, and retrieval over years of messy enterprise data, half of it untagged, duplicated, or quietly out of date, is its own unsolved problem. Anyone who has fought their own company’s search knows the distance between “it’s in there somewhere” and “the system reliably puts the right thing in front of you.” And even at its best, plenty never makes it into the index at all. Grounding pushes the first wall back impressively. It doesn’t remove it, and it does nothing for the second.
Because the second wall isn’t a document at all. The partner with twenty years and a few hundred deals behind him negotiates better not because he has read more files but because he’s got calibrated priors about which risks actually bite and which ones never do. None of that retrieves. There’s no folder to point at, no Graph to index it into, because it was never written down anywhere. Knowledge work has no equivalent of checking it into a repo, and the most important inputs are exactly the ones that were never written down to begin with.
A better-grounded agent is a better producer. It still has no oracle, and it still can’t tell you what the report failed to mention.
Same model, different day
There’s a human layer too. The same agent runs the same task and gives you something sharp on Tuesday and something mediocre on Thursday. If you understand sampling and context limits and how much these systems move with small changes in phrasing, you shrug and run it again. If you don’t, and most professionals genuinely don’t, you’ve just met an unreliable colleague, and you quietly stop handing it anything that matters.
That’s not a capability gap, it’s a literacy gap, and a design failure as much as anything. The model is only ever one part of the system, and harnesses built by engineers tend to assume the user shares the engineer’s mental model of why the thing misbehaves. Knowledge workers got a tool that expects them to already know why it’s flaky, when a harness meant for them should be surfacing its own uncertainty and saying this one needs a second look.
What a harness for this would actually need
I’ve spent significant time building these scaffolds, the verification layers and the context orchestration and the omission checks, for the diligence domain. They work. And the thing that won’t leave me alone is that none of them generalize well. The moment you make one of these genuinely useful on a real deliverable, it has to encode what that kind of work owes its reader, and what a quality-of-earnings report owes an investment committee is not what a market study owes a product team. The severity of a given gap is itself a domain judgment, not a universal one. The closer you look, the more the supposedly general tool turns out to be a frame for hanging domain-specific judgment on. The fit is the whole point, and the fit is what doesn’t travel.
If I sketch what most knowledge work actually asks for, it looks almost nothing like a coding harness. You’d need a feedback loop that isn’t a test suite, something doing omission detection and coverage-of-risk checks and citation-to-claim binding, with an adversarial pass whose only job is to hunt for what’s missing rather than what’s wrong. You’d need context orchestration treated as a first-class part of the system, reconciliation with provenance across sources that conflict and sources that are half-tacit, not just retrieval. You’d need calibrated uncertainty handed back to the user, the harness knowing when to say this needs a partner’s eyes the way a good junior knows when to escalate. You’d need a workflow that can branch and backtrack and reconcile instead of marching down a pipeline. And you’d need an accountability trail, because someone is liable, a record of what got checked and why and not just a final answer.
That last one isn’t a feature, it’s the point of the whole exercise. As production gets cheap, the human role moves up the stack, from producing the work to governing the system that produces it. The professional of the near future looks less like a producer and more like a governor, someone who sets the constraints the system runs under and takes responsibility for the result. A harness for knowledge work is really a harness for governance, and almost nothing on the market is built for that yet.
The actual open problem
Coding got a substrate, tests and types and a repository, that generalized across nearly all of software. Python or Rust, a web app or a compiler, the same basic loop holds, and that substrate is the reason a coding agent works at all.
Every knowledge-work scaffold that works is largely bespoke, and it shatters the moment you point it at different work. Building a feedback loop for one domain is doable, I’ve done it more than once. Building one that generalizes the way tests-and-a-repo generalized across coding is the actual open problem, and I don’t think the productivity story everyone keeps promising for knowledge work arrives until somebody solves it. That’s what I’m working on now.
I think we need to be honest about which parts of this are permanent and which are just early. The tacit-judgment wall, the liability bar, the impossibility of testing a silence, those feel structural to me. The context plumbing and the literacy gap will get better with tooling, and they already are, Work IQ being a real step even with the boundary it inherits. And the strongest objection cuts the other way: coding itself was written off as un-automatable craft until the harness caught up, so maybe knowledge-work harnesses simply haven’t been seriously built yet. A smarter model doesn’t hand you an oracle, and it doesn’t absorb the liability. Neither of those gets fixed by scaling. They get fixed by building.
If you’re working on the harness layer for knowledge work, at a lab or anywhere else, I’d like to compare notes.
This article was republished from my X article here https://x.com/arsalanpardesi/status/2069936337940078627?s=20
A Message from AI Mind
Thanks for being a part of our community! Before you go:
- 👏 Clap for the story and follow the author 👉
- 📰 View more content in the AI Mind Publication
- 🧠 Improve your AI prompts effortlessly and FREE
- 🧰 Discover Intuitive AI Tools
