The deeper I get into working with AI, the less interested I am in chatbots. Not because they aren’t useful. They obviously are. But asking a model a question and receiving a block of text feels increasingly like the least interesting version of this technology. The bigger shift is happening around agents.

Give the model tools.

Give it context.

Give it memory.

Give it permissions.

Give it an objective.

Then allow it to actually do something.

That starts looking much less like ChatGPT and much more like a digital worker. And things get interesting pretty quickly from there.

Doomers, Scouts, & Accelerationists I first heard these terms on an amazing podcast series “The Last Invention” by Longview. To summarize, there are different camps forming around where all of this might be heading.

On one side you have the Doomers.

The argument is fairly straightforward:

Advanced AI could become extraordinarily dangerous, potentially even existentially dangerous, and we should dramatically slow development until we understand how to control what we are building.

On the other side are the Accelerationists.

Keep building.

Push harder.

More intelligence means more innovation, scientific discoveries, productivity, abundance, and potentially solutions to problems humans have struggled with for generations.

Then you have what I think is probably the most interesting group: Scouts.

The technology is probably coming whether we like it or not.

The upside could be enormous.

The downside could also be enormous.

So maybe we should start preparing.

I can appreciate portions of all three arguments.

Humans are competitive and curious, and historically we haven’t been particularly good at collectively deciding something like; whether or not a technology might become too powerful. And then subsequently agree that everyone stop working on it.

Good luck with that.

At the same time, “move fast and see what happens” becomes a questionable engineering philosophy when the theoretical end state involves intelligence surpassing our own. Which brings us to…

AGI & ASI

This is where the AI conversation starts sounding like science fiction. Until you realize the people actually building these systems are talking about the same thing.

AGI — Artificial General Intelligence generally describes AI capable of performing across a broad range of intellectual tasks instead of being optimized for a narrow purpose.

Essentially, something surpassing general human-level capability in any intellectual domain.

Then there is: ASI — Artificial Superintelligence. Machine intelligence substantially beyond the combined intellectual capacity of all humans across every. That distinction matters.

Humans currently sit at the top of the intelligence food chain.

We aren’t the strongest animal.

We aren’t the fastest.

We don’t have particularly impressive teeth.

Intelligence was our cheat code.

We built tools.

Then machines.

Then computers.

Then networks.

Now we are using those computers to attempt to build intelligence.

What happens if that intelligence becomes dramatically better than ours?

¯\(ツ)/¯

Anyone confidently giving you an exact answer is probably selling something.

Maybe AGI is decades away.

Maybe it requires another architectural breakthrough.

Maybe the definition moves every time AI reaches the previous goalpost.

Maybe one day we realize we crossed the line five years earlier.

I don’t pretend to know.

That uncertainty is part of what makes it so interesting.

The Harness

Something I think gets overlooked in all of this is that the model itself is only part of the system.

We spend a lot of time comparing:

GPT-this.

Claude-that.

Gemini-whatever.

Benchmarks.

Context windows.

Reasoning scores.

But once you start actually working with agents, the surrounding system matters just as much. That surrounding system is often referred to as the harness.

Tools.

System instructions.

Context.

Memory.

APIs.

Shell access.

File access.

Permissions.

Rules.

Approval gates.

Subagents.

Validation.

Retry logic.

The model is the engine. The harness is the rest of the vehicle. A great engine sitting on the garage floor isn’t particularly useful. And interestingly, a slightly weaker model inside a well-designed harness can sometimes outperform a stronger model surrounded by terrible context and poor tooling.This is also where AI engineering starts looking suspiciously like…

regular engineering.

Markdown Engineering

Which leads to something considerably less exciting sounding.

Markdown files.

Yep.

The little .md files we have been throwing into Git repositories forever suddenly became extremely useful.

README.md

AGENTS.md

ARCHITECTURE.md

PROJECT_STATE.md

SECURITY.md

RUNBOOK.md

DECISIONS.md

etc.

LLMs are incredibly good at consuming structured natural language. That means markdown becomes a lightweight interface between humans and agents. I have been experimenting with this quite a bit in development projects.

Instead of explaining the architecture every time an agent starts:

Read ARCHITECTURE.md.

Instead of explaining which commands it can safely execute:

Read AGENTS.md.

Instead of trying to remember where we stopped three days ago:

Read PROJECT_STATE.md.

Instead of wondering why some strange architecture decision exists:

Read DECISIONS.md.

It isn’t glamorous.

No spinning holographic AI brain.

Basically just disciplined documentation. But when your new developer can read the entire project handbook in a few seconds, documentation becomes executable context. And I suspect managing context may become one of the most important skills in working with AI.

Garbage context in.

Garbage decisions out.

Swarms & Orchestration

One capable agent is interesting.

A team of specialized agents gets even more interesting.

You might have:

an orchestrator deciding what work needs to happen,

a backend agent handling APIs and databases,

a frontend agent handling UI,

a security agent reviewing trust boundaries,

a testing agent trying to break everything,

and a reviewer checking the final result.

Instead of asking one model to think about every part of a giant problem simultaneously, you divide the problem into smaller pieces and assign those pieces to specialized agents.

Essentially:

digital coworkers.

Of course, adding more agents doesn’t automatically make the system smarter. Sometimes you just end up with five extremely confident robots agreeing with each other’s bad idea.

Good orchestration still requires:

clear responsibility boundaries,

independent validation,

shared state,

conflict resolution,

permissions,

and knowing when the humans need to get pulled back into the loop.

The piece that grabs my attention is the potential scale.

Today I work with a couple of agents on a software project.

Tomorrow maybe those agents manage additional agents.

Eventually the primary bottleneck might not be physically writing code.

It might be accurately defining intent.

What are we trying to accomplish?

What boundaries must never be crossed?

What does success look like?

How do we verify the result?

The actual implementation may increasingly become the machine’s problem.

Whatever Comes Next I have no idea where this ends but we are living in the most interesting time in history.

In a remarkably short period of time we have moved from autocomplete to LLMs, multimodal systems, reasoning models, tool use, coding agents, persistent memory, and increasingly autonomous workflows.

Some of the hype is absolutely hype. Marketers gonna market.

Agents still make dumb mistakes.

Models confidently invent things.

Demos are carefully curated.

There are plenty of rough edges.

But dismissing the technology because today’s systems aren’t AGI feels a little like dismissing the early internet because downloading a picture took 45 seconds.

The interesting part isn’t only what the technology can do today.

It is the trajectory.

For software development, humans may gradually move away from manually writing every line of code and toward designing systems, defining constraints, managing context, orchestrating agents, and validating results.

For cyber security, AI is empowering security teams (and threat actors).

For business?

Science?

Society?

^_^

We’re probably going to find out.

And apparently we decided to build all of this in production. Commit to main!