agent-summary

Generate short live progress summaries for the atopile agent from recent tool events, preambles, checklist changes, and build state. Use for ephemeral UI activity text only, never for transcript replies or autonomous reasoning.

3,147 stars

Best use case

agent-summary is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Generate short live progress summaries for the atopile agent from recent tool events, preambles, checklist changes, and build state. Use for ephemeral UI activity text only, never for transcript replies or autonomous reasoning.

Teams using agent-summary 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

$curl -o ~/.claude/skills/agent-summary/SKILL.md --create-dirs "https://raw.githubusercontent.com/atopile/atopile/main/.claude/skills/agent-summary/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/agent-summary/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How agent-summary Compares

Feature / Agentagent-summaryStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Generate short live progress summaries for the atopile agent from recent tool events, preambles, checklist changes, and build state. Use for ephemeral UI activity text only, never for transcript replies or autonomous reasoning.

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

SKILL.md Source

# Purpose

This skill is for a lightweight summary model that makes the agent feel alive while it works.

It does not plan, reason, or steer the task.
It only rewrites recent real events into one short live status line for the UI.

# Inputs

The summarizer should receive a small structured window, for example:

- current phase
- latest model preamble
- last 3-8 meaningful tool events
- latest checklist delta
- latest build/run status
- touched files or targets when available

Only summarize what is present in the input.

# Output Contract

Return exactly one short progress line.

Rules:

- 6-16 words preferred
- one sentence fragment, no bullet, no prefix
- present tense
- no first person
- no user instructions
- no questions
- no claims about completion unless the input says so
- no speculation about hidden work
- no mention of internal implementation details unless directly useful

Good:

- `Reviewing the motor driver package layout and pin mapping`
- `Editing the STM32 wrapper and tightening power constraints`
- `Running a build to validate the new package targets`
- `Checking build errors against the updated driver modules`

Bad:

- `I am thinking about how to solve this`
- `The agent is almost done`
- `Working hard on your request`
- `Maybe updating the power stage and probably the MCU too`
- `Would you like me to run a build?`

# Priority

Prefer the most concrete current activity:

1. error or stopped state
2. waiting on user input
3. active build or build review
4. active file edits
5. part/package search or vendor-document research
6. planning or general review

If multiple events exist, summarize the most recent meaningful step, not the whole history.

# Event Interpretation

Use these patterns:

- `project_read_file`, `project_search`, `project_list_*`: reviewing or inspecting
- `project_edit_file`, `project_create_*`, `project_move_path`: editing or restructuring
- `parts_search`, `parts_install`: selecting or installing parts
- `packages_search`, `packages_install`, `package_create_local`: creating or wiring packages
- `web_search`: checking vendor datasheets, design guides, or application notes
- `build_run`: running a build
- `build_logs_search`, `design_diagnostics`: reviewing failures or diagnostics
- checklist `doing -> done`: moving from one milestone to the next

Prefer file names, package names, target names, or subsystem names when available.

# Safety

Never invent:

- files that were not touched
- parts that were not searched or installed
- build results that were not reported
- design choices that were not made
- progress beyond what the event stream supports

If the input is vague, stay vague but still concrete:

- `Reviewing the current project structure`
- `Planning the next implementation step`

# Usage

This summary is ephemeral UI state only.

Do not:

- write to the transcript
- create assistant chat messages
- replace tool traces
- replace checklist updates

It is a presentation layer over real events, not a source of truth.

Related Skills

lsp

3147
from atopile/atopile

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

3147
from atopile/atopile

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

3147
from atopile/atopile

## Goal

sexp

3147
from atopile/atopile

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

3147
from atopile/atopile

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

3147
from atopile/atopile

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

3147
from atopile/atopile

You are a package specialist.

library

3147
from atopile/atopile

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

3147
from atopile/atopile

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

3147
from atopile/atopile

Frontend standards for atopile extension webviews: architecture, contracts, design system, and testing workflow.

faebryk

3147
from atopile/atopile

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

3147
from atopile/atopile

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.