KISS my A....

Keep It Simple my Agent

We are navigating a Cambrian explosion of AI developer tools. No week without new framework, bespoke agent harness, MCP server, or library of specialized “skills” designed to supercharge our workflows. For us developers, the temptation to jump this train is real. After all, building and mastering complex systems is what we do.

But frameworks don’t just add capability; they freeze assumptions.

That’s fine when those assumptions match the model’s needs. It becomes harmful when the model no longer needs them.

At that point, the framework stops being leverage and starts being constraint:

• you conform your workflow to the framework,
• you shape your context to fit its abstractions,
• you inherit lock-in to its conventions.

It’s an irony that the reliability layer often becomes the source of fragility.

Look at the coding agents from the major AI labs. Strip away the branding, and they are remarkably similar. Most converge toward the same interaction model, and many are just chasing Claude Code as the gold standard.

This convergence is not a coincidence — it reflects the natural gravity of what actually works for a frontier model to operate autonomously inside a codebase.

If it’s truly valuable, the agent will absorb it

Planning mode, task lists, structured iteration, workspace awareness, terminal multiplexing. These aren’t niche tricks; they are general productivity primitives. When a primitive is broadly useful, it migrates into the core product.

Workflows that required third-party tooling show up as first-class features (workspaces, tmux integration, todo lists). External tools become prosthetic.

The pattern is clear — if a workflow pattern genuinely provides value, the agent absorbs it. Hand-rolled scaffolding becomes dead weight.

If you really need tools, use them. But treat them as disposable, not foundational.

The Chaos of Skills and MCPs

We are enamored with “skills” and complex Model Context Protocols (MCPs). Marketed as ways to give superpowers, these tools often achieve the opposite.

At their core, skills are merely syntactic sugar for intent recognition. They are abstractions designed to map a user’s prompt to a specific function execution. But when you equip an agent with dozens of interconnected skills and MCPs, you create a massive routing problem. The agent is forced to expend its cognitive bandwidth deciding which tool is the appropriate one to use in a given scenario.

The agent struggles to understand the nuances of its bloated toolkit. Furthermore, these tools inject data into the context window without oversight.

In agentic development, losing control of the context window is fatal. The dead sin.

The developers who stack the most tools are rarely the most productive. I have seen it. They are the most busy — which is a different thing.

First Principles: Context Is Everything

If we discard bloated toolchains, what are we left with? First principles. Keep It Simple, Stupid (KISS).

Strip the problem down to its core and what remains is simple. An agent is a language model operating within a context window. Everything it knows, everything it can reason about, everything it decides to do flows from what is in that window. The quality of your output is bounded by the quality of your context.

This means the highest-leverage activity is managing context with precision. Not managing more tools.

Clear instructions. Well-structured rules files. Thoughtful progressive disclosure — not through a framework, but through explicit direction.

Read the architecture doc in /docs/arch.md before making changes to the API layer.

That’s it. No skills engine required. No intent-recognition layer. Just a sentence that puts the right information in front of the agent at the right time.

I need full control of my context window. Every MCP, every skill, every extension is something that competes for space in that window and introduces decisions I did not make. When I tell the agent exactly what to read, use, and apply, there is no ambiguity. There is no routing logic to second-guess. The agent gets precisely the context it needs.

Instead of relying on a complex vector database integration or MCP servers to fetch documentation, rely on the simplest and most robust technology available: plain text.

The only durable control surface is the context window

Everything an agent does is a function of context:

• rules,
• the repository state,
• the relevant docs,
• and the tool outputs it has seen.

That is the first principle. It does not change when frameworks or agents change.

Instead of pre-loading an agent with a dozen external tools, write clean, structured Markdown artifacts.

The quality of these artifacts is what really matters! Here you should spend your energy!

• strict, minimal instructions with clear precedence,
• explicit references to artifacts instead of implicit “skills,”
• avoidance of “just-in-case” information.

The Golden Rule

No fix until I can precisely name the recurring failure it fixes. A concrete failure. A measurable friction point. A repeated cost.

Then I add the smallest possible mechanism to address that one issue. Most of the time this is just adding a simple instruction to the AGENTS.md.

Resist Paralysis

The number of tools out there creates a risk of analysis paralysis. It’s easy to spend days evaluating MCP servers, comparing frameworks, and reading blog posts about the “ultimate agentic setup.”

None of this ships features. None of that fixes bugs.

YAGNI exists for a reason. Do not add tooling until the absence of it is a proven, repeated bottleneck in the actual workflow — not a hypothetical one you read about on Hacker News. And when you do hit a genuine bottleneck, check first whether the next agent release already solves it. Odds are decent that it does, or will soon.

Keep It Simple

The developers who are most effective with coding agents are not the ones with the most elaborate setups. They are the ones who understand the fundamentals:

• context is king
• instructions are the primary interface
• simplicity compounds.

Treat the agent’s context window as the most precious resource in the workflow. Keep the setup ruthlessly simple, rely on plain-text instructions, and let the base models do the heavy lifting.

Resist the urge to abstract what does not need abstracting.

Keep it simple. Put your attention where it compounds:

Context!

If you control the context window, you control the agent. Everything else is noise.