⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

agentic-walkthrough

sno-ai@sno-ai⭐ 864 stars· last commit 3d ago· 1 open issues

Prove that a reported run caused its intended real effect. Walk the executor path from entry to effect, capture one observable per hop, and report a result a no-op could not produce.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐ 864 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Sno Station Skills — The working habits of a real team, installed into your AI agents.

Sno Station — Agents, assemble. Two heads are better than one, and smarter by morning.

license Apache-2.0 38 skills in 29 units self-tested before every release agents Claude Code, Codex

Find out more on our website, sno.ai.

Install

All skills with Sno Station

Copy this prompt into your agent's chat:

Install sno.ai from GitHub.

This installs Sno Station and sets up all 38 skills, plus the programs they call, for the supported agents it finds on your machine.

Or paste this command into your terminal:

curl -fsSL https://sno.ai/install | sh

Already have Sno Station? Run sno setup to install the skills into your agents. Run it again if you add another agent later.

Install one skill

Use the copy button on either prompt below, then paste it into your agent's chat. Your agent finds and installs the skill; you do not need to download or copy files yourself.

peer-review checks code, plans and documents with a reviewer from another model vendor. It needs Sno Station programs and a logged-in reviewer. The prompt checks those dependencies first.

Install only the peer-review skill from https://github.com/sno-ai/sno-station-skills
for this project, including its scripts and references.
Check its dependencies and tell me what is missing before installing anything else.

less-is-more helps your agent write less code and remove unnecessary complexity. It can run without Sno Station.

Install only the less-is-more skill from https://github.com/sno-ai/sno-station-skills
for this project, including its scripts and references.

tag-team puts two agents on one task: one builds, the other reviews, and they settle the findings between themselves. It needs Sno Station's Reach program. The prompt checks for it first.

Install only the tag-team skill from https://github.com/sno-ai/sno-station-skills
for this project. Check that `sno reach pair --help` works and tell me what is missing
before installing anything else.

Supported agents for Sno Station: Claude Code, Codex, OpenClaw and Hermes Agent. Each skill declares what it needs from the agent. Setup uses that declaration to install it fully, install it in a reduced form, or skip it when the agent cannot run it.

Updates come by themselves: sno updates itself when it finds a newer release. The full command list is in Sno Station's command reference.

Install as a plugin

Claude Code:

claude plugin marketplace add sno-ai/sno-station-skills
claude plugin install sno-station@sno-ai

Codex:

codex plugin marketplace add sno-ai/sno-station-skills
codex plugin add sno-station@sno-ai

sno-station holds all 38 skills; most of them call Sno Station programs, so install Sno Station too. For only the 7 skills that run without Sno Station, install sno-station-standalone@sno-ai instead.

Install · What changes for you · Why these skills · The pain, and what fixes it · Stories from our own machine · The skills · Built to be trusted · For skill authors · License

What changes for you

You keep working exactly as before, in whichever agent you like. Then:

  1. You finish a change and want it checked. Say "peer-review this". A reviewer from the other vendor reads it cold, reports what would break in real use, and the author fixes the root cause, round after round, until the review comes back clean.
  2. You start a long run before bed. Say "arm rotate-agent". If the working agent's quota drops to the threshold overnight, it hands the task to a fresh agent from the other vendor, with the brief verified before a single file is touched.
  3. You come back. Say "away brief". One page, at most 60 lines: what got done, what is stuck and why, what waits for your answer, and what it cost in quota.
  4. You have a job for someone else. Say "write a charter". You get one file that says what to deliver, what is out of bounds, what you already decided, and how each success check will be proven. Any agent can then deliver it, and every check is proven by a recorded real run.
  5. Every night, the team looks back. The nightly loop reads the day's Claude Code and Codex sessions, finds the mistakes that repeat, and proposes lessons and skill changes. In the morning you accept the ones you like with sno rem-reflect accept <id>. Nothing changes without that accept.

Why these skills

One AI agent is a brilliant new hire with no colleagues. It reviews its own work, so it misses what it cannot see. It stops dead when its quota runs out, at 3 a.m., halfway through your build. It says "done" when the tests are green and nothing actually happened. It builds three layers of machinery you never asked for. And tomorrow it makes the same mistake it made today, because nobody told it otherwise.

Sno Station Skills fixes the team, not the model. These are the skills Sno Station installs into the agents you already run. They give Claude Code and Codex the habits every good engineering team has: a second pair of eyes from a different vendor, a clean handover when someone has to leave, a lead who hands out work with a written definition of done, a one-page brief when you come back, and a retrospective every night that turns this week's mistakes into next week's rules.

Dual Brain: different roles, one team. One agent carries out your task. The other reviews the result against your requirements. Claude Code and Codex can take either role. When both CLIs are installed, the review runs in the other vendor's CLI, in a fresh session with none of the author's conversation. The agents exchange findings and corrections. Add more roles, and you have an Agent Squad.

Work that finishes while you sleep. Arm it before bed, and when the working agent's subscription runs low it writes a handover brief while it still can, wakes an agent from the other vendor, and hands the task over with the exact commit to continue from. Your build does not care which vendor finished it.

"Done" means proven. Every task can carry a written list of success checks, each one answered pass or fail by a real run. Nothing counts as done because an agent said so.

Tested before it ships. Every skill in a release passed its own self-tests on a clean copy, was scanned for personal paths and leftovers, and carries a stamp that says so. A skill that fails is not published.

How it works: two agents, one shared workspace, three things you get

The pain, and what fixes it

Last updated 2026-10-23. Every line in the left column is a real complaint from r/ClaudeCode, r/codex or r/ClaudeAI in the week of October 20, 2026. The right column is what runs on our own machines, free and open source, to make it stop.

What people said this weekWhat fixes itWhere
“Ran out of my 5-hour limit within 30 minutes.”Stop sending the biggest model to do everything. Opus plans and reviews; Codex writes the code, called as an age

// HOW IT'S BUILT

// FILES

3 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • plugins/sno-station-standalone/skills/agentic-walkthrough/SKILL.md6.6 KBa438b2479478upstream ↗
    ---
    name: agentic-walkthrough
    description: "Prove that a reported run caused its intended real effect. Walk the executor path from entry to effect, capture one observable per hop, and report a result a no-op could not produce."
    requires:
      programs: []
      harness:
        - {slot: 4.shell, need: required}
        - {slot: 4.file-read-write, need: required}
    ---
    
    # Agentic Walkthrough — take the program's seat
    
    The stance is the whole method. You are not a reviewer standing outside the code with a
    checklist; you are the thing the source describes — the job, the stage, the handler — and
    you run it in your head, hop by hop, exactly as it would run, noticing every switch you pass
    and every place your output goes. Only then do you turn to the real system and make it show
    you that what you just walked actually happened. The principle: BE the executor, then make the
    executor prove itself.
    
    Ordinary debugging starts from a failure — an error, a red test, a wrong number. This starts from
    the opposite and much quieter case: **everything reports success and you still do not know whether
    the work happened.**
    
    That case is real and it is not rare. A stage that cannot do its work can still report `done`. A
    job can start, finish, write a trace, and pass its own verification while touching nothing. No
    test suite catches this, because no assertion in the suite is false.
    
    Three moves, in order. How far to take each is your judgment — often the first cannot finish
    without the ones after it.
    
    ## 1. Walk the path — be the program, read, don't run
    
    Put yourself where the code sits and go hop by hop from entry point to effect. You are reading,
    not executing, which is the whole point: a live run cannot show you the branch it never took.
    
    Three questions at each hop are usually enough:
    
    - **What switch controls this hop, and what is its value right now?** A config key, an env var, a
      feature flag, a job type, a default argument.
    - **If that switch is off, does it fail loud or continue quiet?** Quiet defaults are where these
      bugs live. Loud failures are already visible — you are hunting the silent ones.
    - **What does this hop actually do — which line?** If you cannot name the line, you have not
      shown the hop does anything.
    
    **The last hop is the one everyone skips and it is usually the decisive one: is this output
    visible to whatever consumes it downstream?** A stage that runs perfectly and writes where nothing
    reads is indistinguishable from a stage that never ran. Check the reader's path, not the writer's
    — they are frequently not the same file, the same directory, or the same database.
    
    Where to start and how deep to go is judgment. Go where the switches are dense, or where the
    evidence gets thin.
    
    ## 2. Probe every hop that has to be real
    
    The walk tells you which hops matter. A probe is how you make one of them prove itself.
    
    **Keep each probe narrow: one observable that only the real thing could have produced.** A broad
    health check is worth little here, because everything passes it — that is the whole problem. The
    walk already told you what this hop is supposed to do; probe exactly that.
    
    These classes come up again and again, and each fails in a way that looks fine from the caller's
    side. Treat them as places to look, not a checklist to complete.
    
    - **Stored state — the rows themselves.** Take a concrete failing case and pull out the actual
      record behind it. A log says a write happened; only the row can distinguish a correct write from
      one that hit the wrong record, wrote the wrong value, or was counted but never committed.
      Landed → the defect is downstream. Did not land → the write logic is wrong, and nothing built on
      top of it is worth tuning. **Expect to need the product's own accessor** — encryption, a key
      held elsewhere, a custom codec. A generic CLI failing to open the store is normal, not a wall.
    - **Database identity.** Which file did the process actually open — resolve the real path — and is
      it the same one the reader queries? Path resolution usually consults several sources in an order
      nobody remembers, and the first one wins.
    - **Model and API calls.** Did a request actually leave? How many, to which endpoint, under which
      model or account? Then the part usually skipped: **does the response contain what the caller
      assumes?** A 200 with an empty body sails through an `if (ok)` check. Zero calls is the loudest
      possible answer and the easiest one to miss.
    - **Accelerator and environment setup.** A path that silently falls back to CPU still finishes,
      just differently. Ask which device the work actually landed on, not whether setup returned
      without error. Same shape for any "configure, then hope" step.
    - **File input and output.** Did the bytes land where the consumer looks? A temp directory that
      gets cleaned, a relative path resolved from a different working directory, an output written
      somewhere nothing reads — all of these leave a successful write behind.
    - **Child processes and third-party services.** Did it actually start, is the thing you matched
      actually it, is it listening, and did it stay up — or exit a second later while the parent
      carried on?
    
    ## 3. Report a number, not an impression
    
    This is the one part worth being strict about, because it is what separates a gate from a reading
    exercise.
    
    **Finish with a number a no-op could not have produced, plus the line where each action happens.**
    *N rows changed, M requests sent, and here is where I can see those N rows differ.*
    
    - **Zero is a failure of the walk, not a result.** It means you found the path broken.
    - **"The walk went well" is not a finding.** Neither is a summary with the numbers dropped.
    - **If you cannot name the line, that action is not proven to run.**
    
    ## Before any absence becomes a finding, check your instrument
    
    Most wrong conclusions here come from a check that could never have said anything else. **Prove
    your check could have produced the other answer** — feed it a case you know is positive and watch
    it fire. Shapes this actually takes:
    
    - `grep -c` against a path that does not exist returns `0`, identical to a real file with no
      matches. Confirm the path exists before the count means anything.
    - A process match can match the wrong process: a wrapper, a script that names your target as an
      argument, or your own shell.
    - A progress check can range over the wrong quantity and read as stalled while the job is healthy.
    - **Timestamps are asymmetric.** An *unchanged* modification time is strong evidence nothing
      touched the file. A *changed* one is evidence of almost nothing — opening a store,
      checkpointing, or migrating a schema all touch the file without doing the work you are after.
    <!-- reminders:start -->
    <!-- reminders:end -->
    
  • plugins/sno-station-standalone/skills/agentic-walkthrough/scripts/selftest/run-selftest.sh1.2 KB1cb83e1bd1c9upstream ↗
    #!/usr/bin/env bash
    # Text contract for this skill only. Reads nothing outside this payload.
    set -Eeuo pipefail
    
    selftest_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
    skill="$(cd -- "$selftest_dir/../.." && pwd)/SKILL.md"
    
    python3 - "$skill" <<'PY'
    import pathlib
    import sys
    
    text = " ".join(pathlib.Path(sys.argv[1]).read_text(encoding="utf-8").split())
    rules = {
        "take the program seat": "BE the executor, then make the executor prove itself.",
        "check the consumer side of the last hop": "Check the reader's path, not the writer's",
        "report a number a no-op could not produce": "Finish with a number a no-op could not have produced, plus the line where each action happens.",
        "zero is a broken path, not a result": "Zero is a failure of the walk, not a result.",
        "an unnamed line is not proof": "If you cannot name the line, that action is not proven to run.",
        "prove the instrument can answer otherwise": "Prove your check could have produced the other answer",
    }
    missing = [name for name, phrase in rules.items() if phrase not in text]
    if missing:
        raise SystemExit(f"agentic-walkthrough: missing load-bearing rules: {', '.join(missing)}")
    PY
    
    printf 'agentic-walkthrough text contract passed\n'
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/sno-ai-sno-station-skills-plugins-sno-station-standalone-skills-agentic-walkthro.md

// REPO STATS

864 stars
1 open issues
Last commit: 3d ago