AI Time Compression: Decisions We Don't Know About

AI does not solve coding. It is compressing time for coding tasks. And this is what makes us struggle with applying this powerful technology.

AI can compress execution time without compressing the number of decisions embedded in the work.

During one of the recent conversations I accidentally mentioned a very interesting angle. A point of view that allows to compare the effort AI is delivering. I called it compression.

It is a comparison of time an agent spent on a task vs the same task to be delivered by a trained human (engineer). High time compression increases decision density. The more consequential those decision are, the higher the risk.

This article shares the concept and the point of view, how to think about what AI really does. Because doing work aka "agentic workflows" are too abstract. We're far away from truly agentic machines, being able to decide. On the other hand - ignoring the fact LLMs change the landscape of modern workforce and especially IT is ignorant.

The Compression

Compression (conventionally) meant squeezing more data in less space. This is achieved by applying algorithms to initial data, represent this data in a way that consumes less memory. And the important part - the compressed data can be restored to the initial data by applying reversed algorithms.

The concept of time compression means one AI prompt can expand to many actions, that are pretty well known and predefined. The beauty of LLM is we don't have to pre-define them ourselves. Modern harness (tooling) can determine what are these actions.

And this is the beauty, the magic and the curse. Because there is usually more than one way to achieve anything. Imagine saving a file. You say your agent: "find a burger recipe and save it on my local disk".

The trap is: what kind of burger? Chicken, beef, vegan? Buns? Onion?

Next: where do I save it? Maybe there are more than 1 disk? Definitely there are more than 1 folder. And your burger recipe end up among receipts and invoices for current month.

The prompt does not contain enough information to execute the task completely. The missing information has to come from context, conventions, learned defaults or guesses. Every guess is effectively a decision, even if the operator never sees it as one.

Now count the question marks above. This is the number of options, therefore decisions that need to be made. Humans have an advanced decision machine built-in. The trick is - most of us has no idea how it works.

The Decision Machine

Daniel Kahneman in "Thinking Fast and Slow" described brain using System 1 and System 2 aliases. If you're technical enough and familiar with a cache - System 1 is a cache. Roughly, but very useful shortcut.

So once we learn something, discover, do something repetitively our brain optimises the execution and moves it to System 1. This is why things we are used to come so natural. We just go, just do, just say. Every day, every week, every year.

A lot of decisions come from System 1, otherwise if we would have to consider each time how we gonna grab a glass of water, a mug of coffee and how to eat steak - our brain would become exhausted dealing with chores. There would be no place for learning, inventing and other sort of deep intellectual work.

System 2 being flexible, powerful and resource hungry is a great gift that could physically exhaust body very fast. Therefore optimisation exists. The tricky part is - before these systems were defined and explained - we had no idea our brains works this way.

The book is deep and System 1 and System 2 are not matched perfectly, therefore biases exist and there is entire book on this. It could be a source for the content for an upcoming year at least. But in context of LLM and AI time compression it gives something powerful.

As a working analogy the LLMs could be compared to external System 1, with tons of default configurations (external again), access to a huge amount of accumulated human knowledge. What it does not have is our responsibility, context, and authority to decide what the correct outcome should be.

But the responsibility of System 2 stays on us. And it means one thing - we are getting exhausted super fast. Because we outsourced much of the routine execution that our own System 1 used to handle, while responsibility for evaluating the result remains with us.

The Cognitive Load

The problem is not only that more code appears faster. The operator must update their mental model at roughly the same speed.

A cognitive load is the amount of mental effort required to process information and complete a task. An LLM operator must follow the results. This is done by following the changes, processing information and possibly data and use it to update our own mental model (mental map).

Mental model is a way we perceive and interact with the world. We can never fit all the details about the world and even a single piece of it, therefore we build simplified models. Some receive more attention and details, while others stay generic.

Creating good software always required a precise mental model of the environment (limitations) and the code (actor). Therefore we've been building actors within specific limitations.

Decision Density

Those question marks you've counted earlier and those decisions behind them trigger System 2, until you have specific shortcuts, that allows System 1 to deal with it. We call these shortcuts professional habits. But it's limiting and takes time to update. So whenever we need a full power, abstraction and understanding - we use System 2. The one that's always hungry.

If work that previously exposed you to a week of decisions is completed in one day, you may now face roughly five times the decision density. Exhaustion comes fast. The dopamine from feeling effective, combined with how easy is to move to the next task, pushes us to keep going. The risk of sustained overload and eventual burnout increases.

Sustained cognitive load makes it harder to maintain the same level of attention and judgement. That's the tax of compression.

Blind Spots

You may rely entirely on LLMs and default decisions. This will save you the energy, but directly affects the results of the work. Average decisions and solutions can produce average results. My personal observation is usually things tend to degrade, until there is a dedicated effort to create a synergy. Synergy means that two or more things work better together than separately.

Moreover default decisions are not articulated. These are silently assumed. And there is no bigger harm when humans do this. And this is why AI compressing the effort brings fast failure. Because the number of implicit decisions grows fast and accumulates together. It is hard to rollback the process and determine which decision had to be made.

Compressed Experience

You may be familiar with a junior developer problem in IT, when there are no tasks left for those starting in industry. These tasks are done fast and good enough by LLMs.

Junior tasks were not valuable only because somebody needed to write simple code. They exposed developers to hundreds of small decisions and details.

When we compress execution, we may compress learning with it.

Those missing decisions are also missing learning opportunities for future experts and specialists. We don't know what we don't know. When we discover something we can not deal with the way we want - we identify it as an unknown, or at least as something we have incomplete or incorrect knowledge about.

Summary

Compress freely: repetitive tasks, deterministic, easy to validate, easy to reverse or replace.

Compress with supervision: known problem space, several reasonable options, moderate consequences.

Do not blindly compress: architecture, security, unfamiliar systems and components, irreversible changes, high-cost decisions.

Two practices helpme: group decisions by complexity, and prepare for important decisions before the agent reaches them.

Ask LLM for options. Apply those options to your own mental model.

Learn, not obey.