We have been flooded by the AI innovations. We constantly hear about new products and capabilities that are being announced. But slowly a pattern has emerged that helps in organising how we work with AI. I am presenting this in form an individual's work stack. My goal is to cover how to think about our work of "coding" and "operating" the digital world.

The stack is simple form is: Human -> Terminal -> Agent -> Capability Bundles -> Tools -> Source Code. This stack helps me figure out where to fit when something new emerges that I want to use.

Human

At the top of this, is us humans. We are the operators of this stack. We have intelligent agents that we can define and instruct to perform tasks. One of our main work is to understand and enhance the capabilities of these agents so that they can do more and more complex tasks for us. These tasks span from writing code, making diagrams, maintaining servers, writing documents, etc.

Terminal

As an important shift we should assume that the terminal is our only interface. We should ask ourself every time we are tempted to move out of it to perform something. The terminal should be where you live most of the time. Hence get the best terminal product you can and learn it well. Optimising our terminal's screen space so we can monitor and use multiple terminal sessions simultaneously. The cognitive cost of switching contexts takes a real toll - hence the optimisation is crucial. Why terminal? Because the terminal is the most natural place to fully control our computer.

Agent

Giving your agent a computer — was a major insight from folks at Anthropic, instead of keeping them locked in IDE. Agents are not just text or code generators (that is what an LLM is). Agents provide models with tools that can interact with a computer. Since they can interact with the computer, they can do everything that we as humans can do on our computers. To internalise this idea, quitting the IDE as the place from which you use agents is quite helpful. Staying within the IDE reinforces the notion that agents generate code and take a few related actions. They can do far more.

We can also create custom agents. These have custom guardrails, instructions, and tools. These are useful to create agents that specialise in repeated and long-running tasks - where we want more control.

Tools

Understanding how agents help models use the tools on our computer, is one of the key ideas for all engineers to fully grasp. This is the fundamental concept behind all the intelligent power we are deriving. Agents are packaged with certain tools, but they can use more tools if those tools are made available or registered.

Some examples of providing tools to the agent:

• gws CLI if you use Google Drive and documents. With gws the model become capable for working with Google Drive. No more using the browser UI, we can just perform everything from the terminal.
• awscli if you are working with AWS and want to perform operations on AWS resources. Similarly, gh for GitHub workflows.

Declarative Agent Programs

These are interesting new concept. Known by skills in Claude code, these are collections of tools, instructions, & scripts that the agent can invoke to perform specific tasks within a coding or operational workflow. These are programs specially meant to be executed by agents - different from program, different from prompts. For example see this Claude Code skill. It is a combination of prompt, program, & cli tool calls. These new class of programs are extremely powerful building block offering new ways of automating work. These are also interactive.

Source Code (including Plain Text Docs)

We want the output to be in plain text format so that it can be read by both language models and humans. Plain text documents (programs, markdown) is where humans and AI meet each other as a common work artifact. AI can work with docx and likes as well, but less efficiently. For most practical usage, markdown can be the source of docx - they are version control friendly. This was already the direction before AI arrived — infrastructure as code, pipelines as code, and so on. AI will extend this to other areas. e.g. we will see more tools that can convert these plain text source documents into visual formats — keeping the source in plain text while generating human-consumable outputs on the fly.

Overall, as software engineers, we are increasingly in the business of operating computers via agents. Writing programs is one such operation. Our responsibilities are: architecture, defining problems, reviewing outputs, and managing risk. We still need to be good at taste, system design, tradeoffs, and long-term thinking. Another important change is the importance of reading.

We all need to get much better at reading the volumes of output that AI generates.

It is worth calling out the psychological aspects, without trying to offer solutions

• Unused credits in your account can cause self imposed guilt of under working.
• This increased productivity is addictive and may lead to overworking.
• Since we get a lot done in shorter time, the cognitive load at the end of the day, can also be overwhelming.
• Increased productivity can also be a self-serving in nature, whereby we don't ask what we are building as long as we are building it fast.

* These CLI tools encapsulate the APIs to these same services. They are easier to manage and to provide to agents compared to raw APIs. Asking agents to use APIs directly would mean we need client libraries somewhere. CLI tools have a few other benefits: - Simpler auth. - Simpler contract for the agent. - Better permission control. - These commands are easily reusable by humans for debugging or manual operations. - They reduce cognitive load on the model, as they are simpler and composable.