The first two years of a programming career are the years where habits set. The senior who writes a failing test before any code, who debugs by following evidence instead of guessing, who never says "it works" without running the verification command, accumulated those habits from a thousand small loops where the alternative cost them an evening. The eight skills below short-circuit some of those loops. Each is a real, verified Claude Code skill from a plugin with public commit history and real star counts.
From the superpowers plugin (206,731 stars). Before any feature, component, or behaviour change, it walks through user intent, requirements, and design. The failure mode it removes is the most expensive one a junior can hit: coding the wrong thing because nobody pressure-tested the requirements first. Five hours of implementation against a misunderstood spec is a worse outcome than five minutes of clarifying questions, and the skill makes those questions automatic instead of the thing you remember after the PR is already up.
When to use: at the start of any feature or bugfix where you are not certain what "done" looks like (most of them in year one), and any time a senior says "just figure out what they need" — the skill is the structured version of that instruction. Pair it with writing-plans below so the brainstorm output becomes a plan the team can review.
Also from superpowers. The next skill that separates a steady junior from a flaky one is the ability to break a multi-step task into a written plan before opening the editor. The skill takes a spec or requirements list and produces a structured implementation plan with concrete steps. Writing the plan first feels slower the first three times and faster every time after — the time it saves is the time you would otherwise spend halfway through implementation realising step four needed step seven done first.
When to use: on any task that touches more than one file or takes more than a single sitting, and as the document you send to a senior to ask "am I about to do this the right way?" before any code is written. Pair it with the architects skill stack on tasks where the plan is genuinely a system-design plan.
Also from superpowers. The single highest-leverage habit a junior can build, and the one that takes longest to internalise without help. The skill enforces writing a failing test before the implementation code, which sounds religious until the third time it catches a misunderstanding of the spec before any production code is broken. The TDD loop also produces, for free, the regression test that prevents the bug from ever coming back silently — a class of value most juniors are taught about and almost none actually capture.
When to use: on every feature, bugfix, and refactor — the activation energy is the whole point, and the skill removes it. Especially valuable on logic-heavy code (parsing, validation, business rules) where the test catches edge cases your head would not have generated. Pair it with systematic-debugging below so the test that drives the fix is informed by a real root-cause investigation rather than a guess.
Also from superpowers. The most common junior debugging pattern is "change something, rerun, change something else, rerun" until the symptom disappears, at which point the bug is declared fixed and the actual root cause survives in the codebase. The skill replaces that with a structured loop: collect evidence, form a hypothesis, test it, narrow the search. It insists on a root-cause statement before any fix lands, which is the single rule that, applied for a year, makes the difference between a junior who plateaus and one who gets to mid-level in eighteen months.
When to use: any time a test fails for a reason you cannot immediately explain, on every "it was working yesterday" report, and on every flaky-test investigation — flaky tests almost always hide a real concurrency or ordering bug that bites later in production. Pair it with the QA-engineer skill stack for the testing-infrastructure side.
Also from superpowers. Fixes the two opposite failure modes juniors fall into on PR review: implementing every suggestion uncritically (including the wrong ones, of which there are always some) or rejecting suggestions defensively because the feedback felt like criticism. The skill enforces a technical-rigor middle path — every suggestion gets verified against the actual behaviour, then accepted, pushed back on with evidence, or escalated for a conversation. The output is the version of you that a senior reviewer actually wants to keep reviewing PRs from.
When to use: on every PR review you receive, especially the ones where the feedback feels unclear or technically questionable — those are exactly the ones where blind implementation hurts the most. Pair it with requesting-code-review below so the loop is closed on both sides.
Also from superpowers. The companion skill: before you ask for a review, run it first. The skill walks the diff against the requirements and the project's conventions, surfaces the issues a reviewer would have flagged anyway, and lets you fix them before the PR goes up. The senior reviewer's time is the most expensive resource the team has on you, and the worst use of it is having them flag the thing you would have caught yourself with one more pass. The skill makes that one more pass a structured thing instead of a vibes-based one.
When to use: before pressing the "ready for review" button on every PR — the alternative is the round-trip where the senior flags the obvious stuff and you push a fix, costing both of you a context switch. Pair it with verification-before-completion below so the PR is one you have actually verified.
Also from superpowers. Fixes the single most common embarrassing-junior moment — saying "it works" in standup before running the verification command, then watching CI go red ten minutes later in front of the whole team. The skill enforces evidence before assertions: before claiming a task is done, the verification command runs and its output is confirmed. The rule sounds obvious; the surprise is how often a green CI run on a clean test output is the difference between a calm Friday and a weekend hotfix.
When to use: before every commit message that says "fixes", every PR description that says "done", every Slack message that says "merged and deployed", and every standup update where you describe a task as complete. Especially valuable when you are tired, the deadline is close, and the change feels small — those are exactly the conditions under which unverified claims become production incidents.
Also from superpowers. Git worktrees are the feature most juniors do not learn about for years, and the absence of them is the cause of the "I had to stash my changes, switch branches to fix a prod bug, and now my stash is a mess" situation that costs an afternoon every few weeks. The skill checks for and creates an isolated workspace before starting feature work, so the in-progress branch lives in its own directory and the hotfix branch can live in another without any stash gymnastics. The senior version of this habit looks like wizardry; it is actually one well-named skill.
When to use: at the start of any feature where you might be interrupted by a prod issue, and any time you find yourself about to type git stash for the third time on the same change — that is the signal a worktree would have saved the afternoon. Pair it with the backend-engineer skill stack on real production work.
How to install
All eight skills live in the same plugin (superpowers), which makes the install path unusually clean: add the marketplace once, install it, and the eight skills are available together. The skill detail page on Skill Index has the exact install command and a copy button. The highest-ROI sequence for a junior in their first six months: start with brainstorming and writing-plans so every task begins with a clear target, then layer in test-driven-development and systematic-debugging so the loop becomes evidence-driven. Add verification-before-completion so the "done" claim is one you can defend, then requesting-code-review and receiving-code-review so the PR loop costs both sides less. Reach for using-git-worktrees once your workflow has enough parallel branches in flight to make stash gymnastics painful. Pair the workflow with deep-work blocks via focus.thicket.sh and quick reference QRs via qr.thicket.sh, and the first two years stop being expensive lessons and start being structured loops you can improve on.