WRITING · ESSAY 02 · 2026-10-25
Learning about AI: preparing for the agentic era
AI literacy is not tool training. It is learning to direct systems, which requires understanding what the systems cannot do.
AI literacy is direction, not tool training
The thesis: AI literacy is not tool training. It is learning to direct systems, which requires understanding what the systems cannot do. Tool training expires with the tool; direction compounds, because the failure modes underneath the tools are stable.
This essay makes that claim concrete the only way I trust: by showing the learning stages in a portfolio that exists, each stage falsified by what the previous stage could not do. No course, no framework, and where I do not know something, the not-knowing is labelled.
The stages, and what falsified each one
Stage one: prompting. The first stage treats the model as an oracle you learn to address. It works, right up to the moment you need a state change: the model can describe a file layout, but it cannot hold one across a session. What falsified prompting as a discipline was state. Anything that mattered longer than a context window needed to live outside the model.
Stage two: frameworks. The second stage wraps the model in chains, agents, and orchestration, and it is where most of the industry is now. Frameworks solve state by convention and fail by the same route: the demo works, the unattended run dies quietly, and nothing downstream knows. What falsified frameworks for me was failure-mode inventory. I catalogued how my own unattended runs died (silent death, evaporated knowledge, host drift, no invariants) and none of those failures was a model failure. They were architecture failures, and no framework fixed architecture by existing.
Stage three: utilities. The third stage is the turn: stop asking the model to do things and give it things to call. Native CLIs, MCP servers, typed schemas, one output contract. The falsification that ended this stage was budget. Utilities multiplied, and each one carried a schema cost per session; a full-load session across the fleet measured 21.8k tokens of schema surface (audit of 2026-08-26; the audit's fleet-wide tool total was later withdrawn in the register, because one member server alone outgrew it). Capability without budget arithmetic is just sprawl with APIs.
Stage four: operating systems. The current stage: the utilities organised into capability classes, governed by typed contracts and executable gates, scheduled by one mechanism, sensed by records that fail visibly. The falsification that defines this stage is still open, which is the honest state of the art at one operator's scale: the sensing layer is the part that is not yet finished, and the postmortem that proves the point is published on this site with its SQL.
The direction of the stages is the literacy. At every stage the scarce skill was not knowing the tool; it was knowing what the tool could not do, and building for that.
What the portfolio is for
The portfolio behind this site is the artifact of those stages: 67 public repositories out of 132 total, counted from the GitHub GraphQL API on 2026-10-24. It is not a trophy shelf; it is the evidence that operator-directed builds are learnable. A reader can watch the stages in the code: the early repos that are framework-era thinking, the utility layer organised by capability, the recent runtimes with their test attributes printed as static counts and their consolidation history left in the register.
That is also why the portfolio is public and the numbers on this site are dated. Learning in the open only works if the failures stay visible; a portfolio that only shows its current state teaches nothing.
An architecture pattern, carried concretely
The archetype readers of this essay want the pattern with tooling attached, not a saga, so here is the one pattern I would hand a working engineer: the capability-class utility with a dual face.
The shape: for any capability an agent needs (memory, browsing, intelligence gathering, content rendering), build one substrate organised behind the capability, expose it twice (an MCP server with contextually relevant tools for agent sessions, a CLI with the full surface for operators and scripts), and give the substrate a typed contract that both faces share. The pattern is visible in the fleet end to end: the intelligence gatherer is one Rust binary with 23 registered MCP tools and a full CLI verb set; the memory server registers 7 tools at roughly 121 tokens per tool while the same capability stays fully reachable at the CLI where schema cost is zero.
Why it works, in failure-mode terms: the dual face means every debugging path is human-speed (reproduce the agent's tool call in the CLI, same schema, same validation), every cost is on one budget line (the token audit that forced the split), and every new platform is an implementation behind an existing class rather than a new architecture. The pattern is the practical residue of stages three and four: it is what "utilities instead of prompts" concretely looks like when it is done.
The counter-pattern is just as instructive: capability per platform. Eight social platforms as eight integrations is eight runtimes, eight credential stores, eight output contracts, and eight places to drift. The capability class (one social-media substrate, eight providers behind it) is what fits on a small host and, more to the point, what one person can maintain with AI augmentation.
What AI changes about learning itself
The stages above were traversed with AI augmentation throughout, and the augmentation changed the shape of the learning in one specific way: the bottleneck moved from production to judgment. I can produce a working subsystem in an afternoon that would have been a month of typing ten years ago. Deciding whether that subsystem should exist, which substrate it belongs to, and how it will fail is where the actual work now lives, and that decision is exactly what the tools cannot do.
Two concrete practices came out of that shift, both cheap to adopt:
- Falsification notes. Every stage transition in the list above is written as what falsified the previous stage. The practice is transferable: when you learn a tool, write down the specific thing it could not do, because that sentence is the real syllabus.
- Measured reversals. When a substrate fails, the reversal is recorded with what was built, what it cost, and what replaced it (the memory-engine removal in Essay 2 is the worked example, including the admission that the replacement decision was qualitative at the time). Learning from reversals requires keeping them; learning without records is just forgetting with confidence.
A third practice sits under both: keep the evidence surface outcome-first. The measurement register on this site is a learning artifact as much as a credibility one, because it forces every claim I would otherwise make loosely to carry a method and a date. Writing methods down is how you find out which of your beliefs were measurements.
What I do not know yet
Three honest gaps, because this essay's archetype readers can smell a curated blind spot.
First, I do not know how these stages scale to a team. Every figure on this site is a single-operator figure; the coordination overheads of multi-operator direction are outside my measured experience, and I will not generalise from one.
Second, the sensing layer of my own system is unfinished (Essay 3 carries the postmortem). I can describe the discipline of self-detection; I cannot yet show a complete execution record for the replacement runtime. When that record exists, the numbers replace the prose.
Third, the boundary between direction and delegation is a judgment call I make per session, and I do not have a rule for it. The tool-surface audit gives the budget arithmetic; the arithmetic does not decide which tools a session should carry. That decision is still mine, and I do not expect that to change, which is the essay's actual thesis wearing its smallest clothes.
If you take one thing
Do not learn tools as tools. Learn each one until you can name what it cannot do, write that down, and let the list choose your next build. The agentic era does not need more people who can prompt; it needs more people who can read a system's failure modes and direct it anyway.
The audience contract this was written under
Written for
- Deep-Dive Subscriber
- Leveraged Principal Engineer
Has to hit
- Data-grounded essays with citations to primary sources
- Honest 'what I do not know yet' sections
- Original synthesis unavailable elsewhere
- AI-augmented architecture patterns with concrete tooling
Rejected if it
- Content that is a teaser for a paid course
- Reformatted social threads sold as essays
- AI-will-replace-everything framing
Figures in this essay: 3, each linked inline to the measurement record with its method and date.