atopile-skills
How to write and maintain `.claude/skills/*/SKILL.md` files: source-of-truth-first process, verification steps, and conventions.
Best use case
atopile-skills is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
How to write and maintain `.claude/skills/*/SKILL.md` files: source-of-truth-first process, verification steps, and conventions.
Teams using atopile-skills 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/atopile-skills/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How atopile-skills Compares
| Feature / Agent | atopile-skills | 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?
How to write and maintain `.claude/skills/*/SKILL.md` files: source-of-truth-first process, verification steps, and conventions.
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.
Related Guides
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
Top AI Agents for Productivity
See the top AI agent skills for productivity, workflow automation, operational systems, documentation, and everyday task execution.
SKILL.md Source
# Skills Skill (Maintaining Skill Docs) This skill describes the process for maintaining the skill documentation under `.claude/skills/*/SKILL.md`. The goal is that future LLM edits stay **accurate**, **actionable**, and **grounded in the repo** (not vibes). ## Quick Start When updating any skill: 1) Find the module’s “source-of-truth” docs (README/design notes). 2) Verify claims directly in code (entrypoints + invariant-enforcing files). 3) Fix incorrect paths/APIs/tests by searching the repo. 4) Add/update a small `## Quick Start` that actually runs in this repo. 5) Validate frontmatter + referenced paths. ## What “Good” Looks Like A good skill doc is: - **Specific**: points at exact files and the *real* entrypoints. - **Invariant-driven**: documents the correctness rules enforced by the code (not aspirational design). - **Runnable**: Quick Start snippets compile/import (or at least match the current API surface). - **Traceable**: any non-obvious claim can be traced to a file path in the repo. ## Standard Workflow (Source-of-Truth First) ### 1) Inventory the skill’s scope - Identify the module boundary (directories, packages) and key consumers (“call sites”). - Prefer using `rg` over memory: look for imports, entrypoints, and key classes/functions. ### 2) Read the docs, then the code that enforces invariants Use this hierarchy: 1. A module README/design doc (if present) 2. The runtime entrypoint(s) used by the rest of the repo 3. The files that enforce invariants (the places that *must* remain correct) 4. Tests that codify behavior Examples: - Solver: `src/faebryk/core/solver/README.md` + `src/faebryk/core/solver/symbolic/invariants.py` - Graph: `src/faebryk/core/zig/src/graph/graph.zig` + `src/faebryk/core/zig/src/python/graph/graph_py.zig` + generated stubs - Library: `tools/library/gen_F.py` is the source-of-truth for `_F.py` ### 3) Fix wrong statements (don’t preserve broken history) Common failure modes in skill docs: - stale file paths (`atopile/src/...` vs `src/...`) - renamed entrypoints (`lsp_server.py` vs imaginary `server.py`) - test paths that no longer exist - claims about behavior that conflict with the actual API surface (especially Zig bindings) Rule: if you can’t prove it from the repo, either remove it or label it as a hypothesis with a pointer to where to verify. ### 4) Add a minimal, correct `## Quick Start` Quick Start should be: - 5–20 lines - uses the *public* API surface as used elsewhere in the repo - avoids placeholders like `src/.../something.zig` Good patterns: - CLI snippet for user-facing flows (`ato build`, `ato dev test --llm`) - Python snippet for core APIs (`GraphView.create()` / `TypeGraph.create(...)`) ### 5) Validation checklist (required) - Frontmatter YAML parses and contains `name` and `description`. - Every referenced `src/`, `tools/`, and `test/` path exists (exclude generated build outputs). - Any code identifiers mentioned (classes/functions) exist (`rg` check). - Quick Start uses correct import paths and function signatures. ## Style/Structure Conventions Prefer this ordering: 1) One-paragraph summary 2) `## Quick Start` 3) `## Relevant Files` 4) `## Dependants (Call Sites)` 5) `## How to Work With / Develop / Test` 6) `## Best Practices` / `## Invariants` (when applicable) Keep the doc concise and “repo-local”: avoid external links unless they’re stable standards docs.
Related Skills
lsp
How the atopile Language Server works (pygls), how it builds per-document graphs for completion/hover/defs, and the invariants for keeping it fast and crash-proof.
solver
How the Faebryk parameter solver works (Sets/Literals, Parameters, Expressions), the core invariants enforced during mutation, and practical workflows for debugging and extending the solver. Use when implementing or modifying constraint solving, parameter bounds, or debugging expression simplification.
SEXP Benchmark Strategy
## Goal
sexp
How the Zig S-expression engine and typed KiCad models work, how they are exposed to Python (pyzig_sexp), and the invariants around parsing, formatting, and freeing. Use when working with KiCad file parsing, S-expression generation, or layout sync.
pyzig
How the Zig↔Python binding layer works (pyzig), including build-on-import, wrapper generation patterns, ownership rules, and where to add new exported APIs. Use when adding Zig-Python bindings, modifying native extensions, or debugging C-API interactions.
planning
Spec-driven planning for complex design tasks: when to plan, how to write specs as .ato files, and how to verify against requirements.
Package Agent
You are a package specialist.
library
How the Faebryk component library is structured, how `_F.py` is generated, and the conventions/invariants for adding new library modules. Use when adding or modifying library components, traits, or module definitions.
graph
How the Zig-backed instance graph works (GraphView/NodeReference/EdgeReference), the real Python API surface, and the invariants around allocation, attributes, and cleanup. Use when working with low-level graph APIs, memory management, or building systems that traverse the instance graph.
frontend
Frontend standards for atopile extension webviews: architecture, contracts, design system, and testing workflow.
faebryk
How Faebryk's TypeGraph works (GraphView + Zig edges), how to traverse/resolve references, and how FabLL types/traits map onto edge types. Use when working with TypeGraph traversal, edge types, or building type-aware queries.
fabll
How FabLL (faebryk.core.node) maps Python node/trait declarations into the TypeGraph + instance graph, including field/trait invariants and instantiation patterns. Use when defining new components or traits, working with the Node API, or understanding type registration.