Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
git clone --depth 1 https://github.com/wednesday-solutions/ai-agent-skillsWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/commands/wednesday-solutions/ai-agent-skills/onboard)<a href="https://agentmods.dev/commands/wednesday-solutions/ai-agent-skills/onboard"><img src="https://agentmods.dev/badge/commands/wednesday-solutions/ai-agent-skills/onboard/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/commands/wednesday-solutions/ai-agent-skills/onboard"><img src="https://agentmods.dev/badge/commands/wednesday-solutions/ai-agent-skills/onboard.svg" alt="Reviewed on agentmods" width="80" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00000 | $0.01563 |
| Opus 5 | $0.00000 | $0.00781 |
| Sonnet 5 | $0.00000 | $0.00313 |
| Haiku 4.5 | $0.00000 | $0.00156 |
Grade A, and why
onboard scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 11d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 261 lines — stays where its author put it; the contents beside it link to each section on GitHub.
/onboard — Developer Onboarding Brief
Purpose
Generate a personalized onboarding brief for a new developer joining the project.
Trigger
- "Generate an onboarding guide"
- "I'm new to this project, where do I start?"
- "Create a developer onboarding brief"
Type: /onboard
Steps
1. Load codebase statistics from DB
const queries = require('./.claude/query-helpers.js');
const stats = queries.getCodebaseStats();
Returns:
- totalFiles, totalEdges, totalLines
- languages (array with counts)
- averageRiskScore, medianRiskScore
- graphCoverage (%)
- testedFiles (count)
2. Load MASTER.md
Read .wednesday/codebase/MASTER.md to extract:
- Product orientation (what the project does)
- Architecture overview
- Tech stack (languages + key libraries)
- Reading order (if available)
If MASTER.md doesn't exist, suggest running /brownfield-map first.
3. Identify risk files to avoid
const highRiskFiles = queries.getHighRiskFiles(minRisk = 60);
Returns files with risk score > 60, sorted by risk. These are the danger zones.
4. Find entry points with confidence
const entryPoints = queries.getHighConfidenceEntryPoints(threshold = 70);
Returns entry points sorted by confidence score. High confidence (>70%) are primary entry points.
5. Identify files by role
const filesByRole = queries.getFilesByRole();
Groups files by their classification:
- Adapters (for external dependencies)
- Logic (core business logic)
- Infra (framework/middleware)
- Entry (entry points)
- Util (utilities)
6. Identify background processes
Background processes are included in MASTER.md and marked via role classification. Adapters from step 5 show external integrations (DB, APIs, payment processors, etc.)
7. Build the onboarding brief
Format:
# Onboarding Guide — <Project Name>
Welcome! This guide will help you ramp up on this codebase.
---
## What This Project Does
[From MASTER.md — 1-2 sentences]
Example: "This is an intelligent code analysis platform that helps developers understand complex codebases through dependency graphs, risk scoring, and AI-powered summaries. Used by 50+ companies to accelerate onboarding and reduce technical debt."
---
## Tech Stack
**Languages:** <list>
**Frameworks:** <list>
**Databases:** <list>
**Key libraries:** <list>
---
## Architecture
[From MASTER.md — 2-3 sentences]
Example: "The architecture follows a layered pattern: parsers read source code, the graph engine builds dependency relationships, analyzers compute risk and impacts, and LLM enrichment adds human-readable summaries. Data flows: parse → graph → analyze → summarize → output."
---
## Where to Start Reading
Read these files in order. Each builds context for the next:
1. **<entry-file-1>** — <what it does & why it's first>
2. **<core-file-1>** — <role in architecture>
3. **<core-file-2>** — <role>
...
[8-12 ordered files from the reading order or computed via fan-in]
> **Tip:** Each file has a summary in `.wednesday/codebase/summaries.json` if you get stuck.
---
## External Dependencies
This project talks to:
**Databases:**
- PostgreSQL (user data, cache layer)
- SQLite (local graph DB)
**APIs:**
- OpenRouter (LLM enrichment)
- GitHub API (PR comments, issue triage)
**Services:**
- SonarQube (code quality analysis)
⚠️ Most require API keys. Check `.env.example` for setup.
---
## Background Processes
- **Cron jobs:** <N> scheduled tasks
- Daily: stale dependency check
- Weekly: skill registry update
- **Event listeners:** PR webhooks, GitHub Actions triggers
- **Async workers:** LLM summarization (can take 30s per module)
---
## Files to Never Touch Without Asking
These are high-risk. Changes here cascade widely:
- **<risk-file-1>** (risk: 78/100)
- <Why it's risky>
- <Who to ask before touching>
- **<risk-file-2>** (risk: 72/100)
- <Why>
- <Owner>
[Top 3-5 danger zones]
---
## First Task Recommendation
To build confidence, start here:
1. Read the entry file and understand the command flow
2. Pick a low-risk utility file and trace its usage
3. Read the architecture summary in MASTER.md
4. Run `/brownfield-map` to generate fresh analysis
5. Use `/brownfield-chat` to ask questions as you go
Once comfortable:
- Pick a small bug from issues (marked "good first issue")
- Use `/brownfield-fix` before editing
- Use `/brownfield-blast` to see your change impact
- Open a PR — we'll review and guide you
---
## Useful Commands
```bash
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 11d ago First seen · 261 lines · 0 tokens per session scan A 93e7cb541d29
onboard is a command published in the GitHub repository wednesday-solutions/ai-agent-skills (168 stars, last pushed 3mo ago), licensed MIT. It costs nothing until one of its globs matches a file; then it loads 1,563 tokens. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.
Other commands, from other repositories
sdd-apply
Implement SDD tasks — writes code following specs and design.
sdd-explore
Explore and investigate an idea or feature — reads codebase and compares approaches.
sdd-init
Initialize SDD context — detects project stack and bootstraps persistence backend.
gentle-sdd-ff
Fast-forward all SDD planning phases — proposal through tasks.
ink-art
Hand-drawn ink-on-white doodle animation — a character that draws itself then walks/dances/waves, or a deadpan contraption explainer. Vector, deterministic, rendered via HyperFrames to MP4.
modernization-flow
Workflow for converting, modernizing, upgrading, or re-architecting code (e.g. C++→Java, monolith→microservices), etc.