walkthrough-creator
Create and maintain the walkthrough artifact during implementation
Best use case
walkthrough-creator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Create and maintain the walkthrough artifact during implementation
Teams using walkthrough-creator should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/walkthrough-creator/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How walkthrough-creator Compares
| Feature / Agent | walkthrough-creator | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Create and maintain the walkthrough artifact during implementation
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
You are maintaining the **Walkthrough artifact** (`walkthrough.md`) for an artifact-driven development workflow.
## Purpose
The Walkthrough documents **what was built**—a clear summary of the resulting system organized by architecture, not by task sequence. It serves as proof of completion and a reference for the finished work.
## Input Context
- Read `.artifacts/bld-<project-slug>/todo.md` for completed tasks
- Read `.artifacts/bld-<project-slug>/implementation-plan.md` for planned architecture
- Reference actual implementation from the conversation
## Your Task
Create/update `.artifacts/bld-<project-slug>/walkthrough.md` as implementation proceeds.
## Walkthrough Structure
### Overview
One paragraph summarizing what was accomplished:
> I've successfully built a [description of what was built] that [key capabilities]. [Additional context on approach or notable features].
### What Was Built
Organize by logical layers or areas (Backend Services, Frontend Components, Configuration, etc.).
For each component:
**1. Component Name** (`filename.ext`)
Brief description of what this component does:
- Capability or responsibility one
- Capability or responsibility two
- Capability or responsibility three
Example:
```
**1. Weather Provider Integrations** (`weatherProviders.js`)
Integrated three weather APIs with data normalization:
- **OpenWeatherMap**: 3-hour interval forecasts
- **Open-Meteo**: High-resolution hourly forecasts (no API key required)
- **WeatherAPI.com**: 14-day hourly forecasts
Each provider's data is normalized to a standard format with:
- Temperature (°C)
- Feels-like temperature
- Precipitation amount and probability
```
### API Reference (if applicable)
Use tables for structured information:
| Endpoint | Method | Description |
|----------|--------|-------------|
| `/api/random-location` | GET | Generate random coordinates |
| `/api/weather?lat={lat}&lon={lon}` | GET | Get aggregated forecast |
### How to Run
Quick instructions to start/use the implementation:
```bash
npm install
npm run dev
# Open http://localhost:3000
```
### Known Limitations
Any constraints, deferred features, or edge cases not handled.
## Artifact Structure
```markdown
---
status: in-progress
created: <timestamp>
updated: <timestamp>
---
# <Project Name> - Walkthrough
## Overview
<One paragraph summary of what was accomplished>
## What Was Built
### <Layer/Area Name>
**1. Component Name** (`filename.ext`)
Description:
- Point one
- Point two
**2. Component Name** (`filename.ext`)
Description:
- Point one
- Point two
### <Another Layer/Area>
...
## API Reference
| Endpoint | Method | Description |
|----------|--------|-------------|
| ... | ... | ... |
## How to Run
...
## Known Limitations
...
```
## When to Update
Update incrementally as major components are completed—don't wait until the end. Each significant piece of functionality should be documented when it's working.
**IMPORTANT**: Every time you modify `walkthrough.md`, update the `updated:` field in the frontmatter with the current timestamp.
## Completion
When implementation is complete:
- Update `status: complete`
- Ensure Overview accurately reflects the full accomplishment
- Present to user as the terminus of the workflow
**When presenting**, always:
1. Show the file path at the top: `📄 .artifacts/bld-<project-slug>/walkthrough.md`
2. If the document is reasonably sized, display the full markdown content
3. If the document is large, provide an overview and instruct the user: "See the full walkthrough at the file path above."Related Skills
task-list-creator
Create or update the task list artifact from gathered requirements
implementation-plan-creator
Create the implementation plan artifact from an approved task list
feature-spec-creator
Generates a feature spec for an existing codebase via an interview workflow. Use when the user wants to write, draft, or scope a feature spec — phrases like "write a feature spec", "spec out this feature", "draft a spec for X", "I want to add X to this codebase", "let's plan a new feature", or "scope out this feature". Do NOT use for bug fixes, pure refactors with no behavior change, or greenfield projects with no existing code.
obsidian-cli
Use the Obsidian CLI to manage knowledge in an Obsidian vault — daily notes, search, tasks, tags, link graph analysis, properties, templates, and file operations. This skill should be used when the user asks to interact with their Obsidian vault, manage daily notes, search notes, manage tasks, explore tags or backlinks, set properties, use templates, or perform vault maintenance.
qr-code
Generate QR codes from URLs, text, or other data and save them as SVG, PNG, EPS, or PDF files. This skill should be used when the user asks to create, generate, or make a QR code for any content such as website URLs, text strings, WiFi credentials, contact info, or other data. Triggers include mentions of 'QR code', 'QR', 'barcode for a link', or requests to make a scannable code. Supports customization of colors, size, error correction level, and output format.
powerpoint
Create professional PowerPoint presentations. Use when asked to "create a PowerPoint", "make a presentation", "build slides", or generate pptx files.
pdf-ocr
Parse PDF files to markdown using GLM-OCR via Ollama locally. Converts each page to an image, runs OCR, and outputs clean markdown. Use when the user wants to extract text from a PDF.
ralph-method
Set up a Ralph Wiggum task - runs Phase 1 (requirements interview) and Phase 2 (implementation planning), then stops with instructions to run the building loop. Creates namespaced specs in specs/[task-name]/.
journal
An agent to journal developer activity over a specified time period.
adr-manager
Add Architecture Decision Record (ADR) entries to an ADR file. This skill should be used when recording significant architectural decisions during development. It handles formatting and appending entries using Michael Nygard's ADR template.
essay-draft-from-research
Produces a long-form essay draft grounded in a user-supplied directory of research documents via an interview workflow. Use whenever the user wants to "draft an essay from my research", "write an essay from these notes", "turn this research directory into an essay", "I've been collecting notes on X, help me draft an essay", or "draft a long-form piece using these sources". Do NOT use for: one-shot summarization of a single document, short notes or tweets under ~600 words, pure research-findings synthesis with no drafting, or essay drafting when there is no research corpus to ground in.
create-skill
Creates a new Claude Code skill that follows the Anchored Interview pattern — ground in a CORPUS, run an interview anchored by that grounding, then produce a single ARTIFACT. Use whenever the user wants to scaffold, generate, or design an interview-style skill — phrases like "make me an anchored interview skill", "create a skill that interviews me about X and produces Y", "scaffold a skill that reads my <corpus> and writes a <artifact>", "I want a skill for spec/draft/plan/findings creation via interview", or any request to build a skill that has the ground-then-ask-then-act shape. Do NOT use for: running an anchored interview on a specific task (this skill *creates* such skills, it doesn't perform them — for that, use or create the appropriate task-specific skill); editing an existing SKILL.md; one-shot transformations with no judgment calls; or skills where there is no corpus to ground in.