Everything is a programming problem.

The AGI moment for knowledge work is here

Over the past few weeks at Aqqrue, we’ve been rearchitecting our agent architecture in pursuit of a near-perfect accounting agent. The learning has been immense and, more often than not, quite humbling. Not because the problems are new, but because the capabilities of current models force you to confront how much of what we call “work” was always just latent computation waiting for the right substrate.

That experience made me want to step back and reflect, on what is being built across the world in the name of AI/Agents. More importantly, it made me want to understand what work actually means in a post-LLM world.

For the purpose of this article, I’m deliberately limiting scope to knowledge work performed on a computer. Physical labor and robotics are out of scope, not because they are less important, but because they will likely be solved via a parallel path: better actuators controlled by increasingly capable models. The ideas here will apply there too, just perhaps later.

---

At its core, One can consider work to be the transformation of inputs into outputs under constraints. For most of human history, this transformation was physical. Wood carved into furniture, Iron beaten into Tools, Rock crushed into foundation and beams. But Over time, especially in the last few decades, a large and growing class of work became symbolic performed using numbers, categories, text, and rules.

Most modern jobs, be it in finance, operations, legal, analytics, support, compliance etc. exist almost entirely in this symbolic world. They don’t differ in essence. They differ only in which symbols they manipulate and which rules they apply.

Knowledge work, then, is not so much thinking as it is execution. Humans temporarily lend their cognitive machinery to the task: ingest symbols, transform them under constraint, emit updated symbols, and clear state. Over time, this looping behavior hardens and evolves into roles, titles, and careers and even to a life well lived.

But at its core, it remains a simple computational pattern. Human mind, which is a general purpose computer is programmed to perform the task.

And we invented computers to accelerate that very computational patterns. And as we all know, it worked spectacularly.

Software multiplied human output. The amount of work one person could do expanded dramatically, depending on which software they had access to. Entire categories of effort collapsed. Tasks that once took teams could now be handled by one person with the right tools. We all got faster. Louder. More productive.

It was true progress.

But software came with two fundamental constraints.

It was rigid. And it was expensive.

Rigid, because software demands that the world be described in advance. Someone has to decide the flows, define the states, enumerate the edge cases, and design interfaces that attempt to shepherd messy human reality into clean, pre-approved paths. A great deal of modern product development has been about this act of compression: forcing open-ended human work into rigid frameworks that can be coded, shipped, and supported.

Once deployed, software does what it was told to do. no more, no less. In the era of software burned onto CDs, this rigidity was physical. In the cloud era, it became procedural: CI pipelines, release cycles, migrations. Faster, but still fundamentally frozen at any given moment in time.

And software was expensive because specifying all that logic required specialists. Programmers became some of the most highly paid people on the planet, not because typing code is magical, but because translating ambiguous human work into deterministic systems is brutally hard. We spent billions, trillions to build B2B SaaS to encode how organizations believed work should happen.

Marc Andreessen famously called this “software eating the world.”
What that really meant was software eating human judgment, one rigid abstraction at a time.

And yet, even as software spread everywhere, humans never quite left the loop. They bent the tools. Worked around them. Filled the gaps. Became the glue between systems that couldn’t fully understand each other.

And we built software that appealed to humans and humans only

That was until recently.

I recently re-read one of my favourite essays, In the Beginning was the Command Line (Must read if you love computers and programming)

Back in the days of the command-line interface, users were all Morlocks who had to convert their thoughts into alphanumeric symbols and type them in, a grindingly tedious process that stripped away all ambiguity, laid bare all hidden assumptions, and cruelly punished laziness and imprecision. Then the interface-makers went to work on their GUIs, and introduced a new semiotic layer between people and machines. People who use such systems have abdicated the responsibility, and surrendered the power, of sending bits directly to the chip that’s doing the arithmetic, and handed that responsibility and power over to the OS. This is tempting because giving clear instructions, to anyone or anything, is difficult. We cannot do it without thinking, and depending on the complexity of the situation, we may have to think hard about abstract things, and consider any number of ramifications, in order to do a good job of it. For most of us, this is hard work. We want things to be easier. How badly we want it can be measured by the size of Bill Gates’s fortune.

The OS has (therefore) become a sort of intellectual labor-saving device that tries to translate humans’ vaguely expressed intentions into bits. In effect we are asking our computers to shoulder responsibilities that have always been considered the province of human beings--we want them to understand our desires, to anticipate our needs, to foresee consequences, to make connections, to handle routine chores without being asked, to remind us of what we ought to be reminded of while filtering out noise.

Neal Stephenson, talks about the computers and OSes, and how they have evolved over the past few decades after personal computing became a thing. How we explicitly rejected word-based interfaces (CLI i <3 u) for more Graphical and Sensorial interfaces purely to dumb down their capabilities for the masses.

Graphical interfaces were bolted onto rigid systems not because computers needed them, but because humans did.

Software required precise instructions, exact inputs, and unwavering obedience to predefined rules. The GUI existed to translate messy human intent into something a deterministic machine could tolerate.

Humans would do the interpretation, and Software would do the execution.

But that arrangement only made sense as long as machines couldn’t interpret intent on their own.

If most knowledge work is programmable logic, and if we now have systems that can write that program, run it, evaluate the result, and revise it when reality disagrees, then the obvious question presents itself:

What role is left for a human to play in executing the work itself?

---

A model with access to a runtime environment and a file system is, for all practical purposes, as close to artificial general intelligence as knowledge work demands. Not because it can “think like a human,” but because it no longer needs a human to act as the execution layer.

• the ability to read and write files, This is your memory

• the ability to execute programs in an environment, This is your action

• and the ability to observe the results and iterate, This is your feedback

That’s the entire so-called agentic loop.

With this setup, the agent can ingest information, store it, transform it, generate new tools for itself, run them, evaluate the results, and revise its approach. It can externalise state, reason over it, and operate indefinitely without relying on fragile context windows or human intervention.

You don’t need a cathedral of agent architecture.

As models improve, they will learn to manage their own context: compact it, reorganize it, and project it outward into durable representations. The file system becomes a knowledge base. The environment becomes an extension of the model’s cognition. What looks like “agent design” today will eventually collapse into capability.

This is why the moment I used Claude Code, something clicked in a way it hadn’t with tools like Cursor.

Not because it was smarter in isolation, but because it inhabited an environment.

A system that could enter a directory, inspect the terrain, create artifacts, modify them, run them, observe what happened, and keep going.

The quality of work then boils down into how long these agents can run autonomously. It’s a function of inference time and inference cost, both of which is guaranteed to reduce. (Moore’s law ftw)

---

Knowledge work doesn’t require consciousness, intuition, or creativity in the mystical sense we often attribute to it. It requires a loop: read symbols, transform them under constraints, emit new symbols, and verify the result.

And this is why coding agents like Cursor, Claude Code, Replit, v0, and Lovable are sitting on top of a gold mine.

Not because they help people write code faster, but because they sit directly inside the fundamental loop of what could be the future of knowledge work.

Every interaction a user has with these systems, every correction, every nudge, every moment of “no, not like that, like this” is a signal. A lightweight but extraordinarily high-quality form of reinforcement. A human acting as a sparse reward function, guiding the system toward intent.

The user isn’t just producing software. They’re teaching the system how to converge: fewer steps and fewer errors. Over time, the iterations shrink. The feedback becomes implicit. What once required an explicit human controller gets internalized by the model itself.

Tighter alignment over intent is what these models need to achieve.

This is a compounding advantage. and most likely why these companies command the valuations they do.

The closer a system sits to execution, and the more tightly it couples action with feedback, the faster it learns to do the work on its own.

Which brings us to the uncomfortable implication for anyone trying to build agents for knowledge work.

If everything is a programming problem, then code is the most natural substrate for agents to operate on. Large language models already understand it deeply, not by accident, but by virtue of their training. Code is abundant in their corpus, structured in a way that mirrors reasoning, and, crucially, verifiable. It produces outputs that can be tested, evaluated, and rewarded with precision.

Any serious agent for knowledge work will need to:

• generate code to express intent,

• execute that code in a real environment,

• observe the results,

• and iterate until the outcome matches the goal.

On top of that, the file system alone might not be enough. Real work requires durable context: business-facing data models that act as a structured knowledge base, connectors that bridge systems of record, and powerful, composable APIs that agents can use as tools.

What we ultimately need to build is a Run time tailored for a specific kind of work.