A Claude Code slash command that teaches senior dev sensibilities — without syntax
I created /senior — a Claude Code slash command I call after any reply where Claude did something I do not fully grasp. It reads the last few messages and teaches me what just happened, in two beats:
Beat 1 — The Parts Name the concept. The moving parts, how they connect, the vocabulary I need to talk about it with engineers. No code.
Beat 2 — The Sensibility The senior dev reframe. Concrete, vivid, non-obvious. Not "best practice" — the specific trade-off, consequence, or scenario that makes you think: oh, that's why this matters.
I can also call it directly: /senior why do people use Docker.
Claude adds a try/catch block to my code. I do not know why. I type /senior:
Beat 1 When code calls an external service, the call can fail for reasons outside your control. Try/catch says "attempt this, and if it explodes, run a fallback instead of crashing." The catch receives the error object. Without it, one failed API call takes down the whole app. Key parts: the try block (the risky operation), the catch block (fallback plan), and optionally finally (cleanup that runs regardless).
catch (error) { console.log(error) } and move on — they swallowed the error and now nobody knows it happened. Senior devs ask: should this retry? Alert someone? Return a graceful fallback? Propagate up so something higher in the chain can decide? The catch block is where your app's reliability lives or dies. A silent catch is worse than no catch — at least a crash is honest.
Now I know what a try/catch is, and more importantly, I know that the catch block is the part that matters — not the try. That second part is the sensibility. That is what takes years to pick up on the job.
The skill loads a knowledgebase every time it runs. That knowledgebase contains:
Frontend, backend, web fundamentals, DevOps, security, and the AI layer — the terms I need to name things, discuss things, and ask better questions. Not to write code. To evaluate it.
The 80/20 cliff (last 20% costs more than starting over). The two modes: delegation (prompt → paste → ship, skill atrophies) vs. acceleration (prompt → read → question → experiment, skill compounds). What AI cannot do: automatic context management, architectural taste, upfront planning. What senior devs do differently with AI: write tests first, plan with minimal AI, manually verify security/auth/payments.
Six levels of agent complexity (prompt chaining through full agents) from Anthropic's Barry Zhang. Plus Dex Horthy's 12-Factor Agents framework — production patterns for LLM-backed systems.
Before writing the skill, I ran 55 web searches across 5 parallel agents. The search had one filter: find senior engineers who also ship with LLMs. Not academics writing about AI. Not junior devs excited about Copilot. People who had the sensibilities already and were now using AI to build faster. Their perspective is the one worth distilling.
Plus the data that frames the problem:
The two-beat format maps onto well-studied mechanisms in learning science. Thirty-three primary sources across educational psychology. Here is what they say.
In 1960, David Ausubel showed that giving learners a high-level map before the detail sharply improves recall. A later meta-analysis (Luiten, Ames & Ackerson, 1980; 135 studies) confirmed the effect holds across every subject and skill level.
Beat 1 of /senior is that map. It names the parts, sets out how they link, and builds a schema — a mental frame the new concept can latch onto. Without one, new facts bounce off or warp to fit whatever frame already exists. Bartlett proved this in 1932: English subjects who heard a Native American folk tale recalled "canoe" as "boat" and dropped every unfamiliar name. The mind does not store what it cannot place.
Beat 2 — the sensibility — is elaboration laid on top of that frame. Craik and Lockhart's levels-of-processing work (1972) explains why this matters: deep semantic processing leaves a far stronger memory trace than shallow intake. The sensibility forces that depth. It asks you to weigh a trade-off, not merely note a definition.
Cognitive load theory gives the answer. Working memory holds about four chunks. When a concept lands as one undivided block — vocabulary, mechanism, and significance all at once — those four slots fill before you can process any of it.
Beat 1 strips away jargon and presents elements one at a time rather than all together. This frees working memory for Beat 2's real work: fitting the new concept into what you already know. Simple-to-complex sequencing, as Van Merriënboer's research confirms, is sound scaffolding.
Beat 1 reduces extraneous and intrinsic load. Beat 2 directs freed capacity toward germane processing. Sweller's key nuance: this only matters for genuinely complex material. For simple topics, load reduction has no appreciable effect.
Allan Paivio's dual coding theory established that the mind runs two systems: one for words, one for images. Information stored in both is far more likely to stick than information stored in just one. His research showed that concrete nouns are recalled better than abstract ones, and that the more vivid a word, the stronger the recall.
This is why the sensibility says "a silent catch is worse than no catch — at least a crash is honest" rather than "proper error handling is important." The first fires both word and image processing. The second fires only words. Dual coding is also why the Economist house style — concrete, image-rich, no purple prose — works at scale: it hooks both memory systems without tripping the "flowery" aversion that technical readers carry.
Clark (2013) and Friston (2009) cast the brain as a prediction machine. It matches each input against a top-down guess. Only the gap — what it got wrong — needs full work. When the guess is right, understanding comes fast.
This is the neuroscience beneath the two-beat format. Beat 1 builds the mental model. By the time Beat 2 lands, the brain has already sketched the structure — it need only handle what is new: the reframe, the trade-off, the consequence. Mayer's pre-training principle (2009) says the same thing plainly: people learn more deeply when they already know the names and traits of the key concepts.
The two-beat format is a compressed version of a broader framework I built for a conference talk on AI-mediated learning. The full version has three layers:
| Layer | Purpose | Cognitive mechanism |
|---|---|---|
| 1. Schema Beat 1 / "baby talk" |
Build the mental structure. Name parts. Establish relationships. Pre-answer orientation questions. | Ausubel's advance organisers, Sweller's load reduction, Bartlett's schema construction |
| 2. Mechanism Beat 2 / "Economist style" |
Visceral, image-rich, accurate. Trade-offs and consequences. Installs the sensibility. | Paivio's dual coding, Craik & Lockhart's deep processing, Clark's predictive coding |
| 3. Technical Full depth on demand |
Original complexity. Implementation details. The progressive-disclosure layer opened when you want depth. | Elaboration for advanced learners, encoding variability (Melton, 1970) |
Bruner's spiral curriculum (1960) supplies the theoretical ground: any subject can be taught at any stage if it is framed the right way. The three-layer stack is a tight spiral — the same concept revisited three times, each pass deeper, all within a single exchange.
Two effects stack. You remember what you produce far better than what you merely read — a finding (Slamecka & Graf, 1978) that holds across 86 studies. The gap widens with time: after a day, the edge roughly doubles.
A second force compounds the first. People who study as if they must teach someone else retain more than those who study for a test — even when they never teach at all (Nestojko et al., 2014). The act of framing knowledge for another mind sharpens your own.
Both forces fire when you use /senior. You do not sit and absorb. You spot the gap in your grasp, shape a question, and judge whether the answer fits your code. Prompting is itself a thinking act. As Chi (1989) showed, the simple work of spelling out each step — why this, not that — binds new knowledge to what you already hold.
Slamecka & Graf (1978) / Bertsch et al. meta-analysis (2007)
Information you create is remembered better than information you read. Across 86 studies and 445 effect sizes: d = 0.40 (nearly half a standard deviation). At delays >1 day: d = 0.64.
Nestojko et al. (2014) / Fiorella & Mayer (2013)
Expecting to teach produces more complete, better-organised recall than expecting a test — even without actually teaching. The expectation alone restructures how you encode.
Chi et al. (1989)
Articulating reasoning — why a step exists, what it connects to — produces deeper comprehension through knowledge integration. Prompting an AI to explain forces this articulation.
Vygotsky called it the "zone of proximal development": the gap between what a learner can do alone and what they can do with a guide. Recent work (PMC, 2025) makes the case that LLMs fit that role. They meet the bar for what Vygotsky termed the "More Knowledgeable Other" — and may widen the zone beyond what any single human mentor could.
But AI holds one edge over human mentors: it does not suffer the curse of knowledge. Once an expert learns something, she cannot truly recall what it felt like not to know it. This is why senior engineers are often the worst people to explain the basics — their skill blinds them to the gaps a newcomer sees. An LLM carries no such baggage. It can meet the learner where they stand, without ego, without assumption.
Collins, Brown and Newman (1989) built a model they called "cognitive apprenticeship" — instruction that makes thinking visible. Its six steps (modelling, coaching, scaffolding, articulation, reflection, exploration) describe almost exactly what /senior does: it drags the expert's silent reasoning into the open, where a newcomer can pick it apart.
The PMC research warns that "continuous AI assistance blurs the boundary between performance and autonomy, enabling students to complete tasks but preventing the development of the independence required to extend, adapt, or creatively apply what they know."
This is precisely the delegation-vs-acceleration distinction. /senior is designed to build independence — you learn the sensibility so you can apply it without the tool next time. It teaches you to recognise the pattern, not to depend on a tutor. The Anthropic RCT found that developers who used AI for conceptual questions scored 65%+, while those who delegated code generation scored below 40%. The mode of engagement determines whether AI builds or erodes competence.
My background is not a weakness. Ten years of turning hard systems into plain speech is the very skill you need to judge whether an AI's output holds up. The translation just runs the other way now.
The old path to senior engineering judgment took 10,000 hours of writing code. Most of those hours built syntax fluency and debugging reflex — both of which AI has made less vital than they were five years ago. What stays irreplaceable is the layer above: systems thinking, trade-off analysis, failure sense, architectural taste.
That layer can be built through aimed cognitive apprenticeship — schema construction, dual-coded intuition, generation-effect learning — without years of syntax drills. Not because the drills are worthless, but because the bottleneck has shifted. The scarce resource is no longer "can you write code?" It is "can you tell whether the code is any good?"
I am not a senior engineer. I am building senior engineer judgment — with method, with a research-backed tool, inside real production work. The aim is not to fake expertise I lack. It is to close the gap between what I can ship and what I can evaluate, fast enough to earn a seat where engineering choices are made.