Intentional News

Being AI Native - Competency Ladder

7 min read

Being AI Native — A Competency Ladder (Prompts → Context → Multi-Agent Workflows)

What this is: a ladder of capabilities for “being AI native” — from basic prompting up to orchestrating multi-agent workflows on a harness like Hermes. It’s a skill progression, not a certification: each rung builds on the last, and the top rungs are about orchestration, judgment and governance, not just knowing more tricks. Seeded 2026-08-24, informed by the FT film on AI literacy (260824 FT Film Does University Still Pay AI Literacy) and web research on context engineering and the “agentic engineer.”

Why this ladder exists

Employers increasingly expect young people (and everyone) to be “AI native” — yet education is behind, and “AI-native” risks becoming a vague buzzword or worse, a new exclusion filter.

This note turns it into something concrete and learnable: a competency ladder that anyone can climb, with the highest-value principle at the top being judgment — because the FT film’s sharpest insight is that AI is a force multiplier on expertise, not a substitute for it. Tools get you so far; discernment gets you further.

The framing deliberately spans “any harness” (Hermes today, but the concepts transfer to Claude Code, Cursor, ChatGPT Agents, Codex, etc.) — so the ladder is durable, not tool-specific.

The ladder

Rung 0 — AI Literacy (the base)

Understanding what LLMs/agents are, what they can’t do, and how to live in an AI-impacted world.

  • What models are (probability engines, not truth machines); hallucination; bias; privacy.
  • “AI literacy is broader than AI as a force for good — it’s learning to live in an increasingly AI-impacted world.” (Atheni / Louise Ballard, FT film)
  • Checkpoint: you can explain how AI is used in your domain, spot a hallucination, and know when not to use AI.

Rung 1 — Prompting (crafting the right words)

Basic, then structured prompting.

  • Clear instructions, context, desired output format; few-shot examples.
  • Iterative refinement: the prompt is a hypothesis, the response is feedback.
  • Checkpoint: you can reliably get a model to produce a useful draft/summary/code snippet for a routine task.

Rung 2 — Context Engineering (curating what the model “sees”)

The shift from “the right words” to “the right configuration of context.” (Anthropic’s framing: prompt engineering → context engineering.)

  • Context is a finite resource with an “attention budget” — context rot means too many tokens degrade recall.
  • Curate system prompts (right “altitude” — specific enough to guide, flexible enough to adapt), tools, examples, message history.
  • Use external context: files, memory, retrieval, wikilinks/knowledge base (the vault), MCP-style tool access.
  • Checkpoint: you design what goes into the context window deliberately — minimal high-signal tokens — rather than dumping everything in.

Rung 3 — Tool Use & Skills (the agent as a worker, not a chatbot)

  • Giving the agent tools: filesystem, web, code execution, search, custom skills.
  • Skills = packaged reusable instructions (like Hermes skills) so the agent “knows” your conventions.
  • The agent uses tools in a loop — this is the transition from chatbot to agent.
  • Checkpoint: you’ve built at least one reusable skill or workflow that the agent follows reliably.

Rung 4 — Single-Agent Workflows (making it repeatable)

  • A defined task, a defined context, a defined toolset, run repeatedly with consistent output.
  • Examples: “file a news article per my conventions,” “regenerate the report from this data,” “fetch + summarise + file.”
  • Add feedback/evaluation: the agent checks its own output; you verify.
  • Checkpoint: you have 2–3 workflows that run reliably and produce verifiable results.

Rung 5 — Multi-Agent Orchestration (many specialists, one conductor)

  • Sub-agent architectures: a lead agent coordinates; specialized sub-agents do deep work in clean contexts and return distilled summaries — keeping the lead’s context tight (the pattern behind Anthropic’s multi-agent research system).
  • Delegation: parallel tasks, each agent isolated, results consolidated.
  • Continuation/chaining: agent output feeds the next stage.
  • Checkpoint: you can decompose a large task into parallel sub-tasks, delegate them, and synthesise the results.

Rung 6 — Judgment, Governance & Risk (the top of the ladder)

The rung that makes all the others safe and genuinely valuable.

  • Disciplined oversight, not raw automation — the agentic-engineer finding is that oversight is the load-bearing competency.
  • Domain expertise as the multiplier: deep knowledge lets you use AI discerningly; the tool amplifies the expert (FT insight).
  • Verification: never trust an agent’s self-report of external effects (uploads, writes, publishes) — verify handles (URLs, paths) yourself.
  • Governance: knowing what not to automate (trading, irreversible actions), privacy (the public: false rule), prompt-injection risk, and when a human must stay in the loop.
  • Checkpoint: you run powerful agents without losing control — you know when to delegate, when to verify, and when to stop.

The one skill that underpins the whole ladder

“The ability to continue to learn and to be willing to go through the uncomfortable process of not knowing stuff and figuring it out.” (FT film)

Every rung above will shift as models improve. The durable meta-skill is comfort with not-knowing + deliberate learning. Rungs are re-climbed, not finished.

How this maps to Hermes (and why “any harness”)

RungHermes equivalent
0Knowing what Alf can/can’t do; when to ask vs not
1Writing good prompts / requests
2The vault as context; .hermes.md, skills, memory, wikilinks
3Skills (file-news-article, obsidian), tools (web, terminal, files), MCP
4Repeatable workflows (news filing, mammouth index regen, freshrss tagger)
5delegate_task (parallel sub-agents), continuation, cron + agent chains
6Verification of side-effects, public: false, never auto-trade, GP-in-the-loop-style HITL

The concepts transfer to any harness (Claude Code, Cursor, Codex, ChatGPT Agents) — the names change, the rungs don’t.

Resource / learning map (to climb the ladder)

Foundational (Rung 0–1):

  • Google’s “AI campus” model and Atheni’s AI-literacy workshops (FT film) — the mindset.
  • Karpathy’s “How I use LLMs” / general prompting guides — the basics.

Context engineering (Rung 2):

Agents & multi-agent (Rung 3–5):

  • Anthropic — How we built our multi-agent research system; Writing tools for AI agents.
  • The arxiv position paper From Determinism to Delegation: AI-Native Software Engineering and the Evolution of the Agentic Engineer (arXiv:2606.28791) — maps the “agentic engineer” competency ladder, SFIA 9, governance (ISO 42001, NIST AI RMF).
  • Anthropic / Simon Willison on agents — “LLMs autonomously using tools in a loop.”

Judgment & governance (Rung 6):

  • NIST AI RMF; ISO/IEC 42001; SFIA 9 (SFIA-online.org).
  • The contested-productivity evidence (Copilot field experiments showing double-digit gains and a slowdown RCT) — evidence that oversight, not automation, is the skill.

Hermes-specific (in this vault):

Open questions

  • What’s the target audience? (the owner himself, the Gen-Z son, or a wider “advising someone” brief?)
  • Should this become a teachable curriculum (with practice exercises per rung) or stay a reference map?
  • Which rung does the owner/Gen-Z currently sit at, and what’s the next step up?
  • The exclusion-filter risk is now concrete (per the ground-truth callout): big firms train, small employers don’t — and apprenticeships already demand work experience. The ladder helps (it’s self-serve and learnable, not inherited), but who carries the on-ramp cost is a real equity question. The household answer is Family On-Ramp to Agents - Non-Technical — the owner as the change lead for his own family, because no employer is going to do it.

Graph View

Backlinks