tracer

Map cross-layer paths and implement features via thin end-to-end slices.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/supertyrelle/pelley --skill tracer-supertyrelle
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: tracer
Source: https://github.com/supertyrelle/pelley/tree/main/skills/tracer
Command: npx skills add https://github.com/supertyrelle/pelley --skill tracer-supertyrelle

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Tracer helps you implement risky or cross-boundary features without betting everything on a big-bang change. It starts with the thinnest possible end-to-end path, so you can prove the flow works before you widen it.

Core Features & Use Cases

  • Thin-slice delivery: Build the smallest working path first, then expand one concern at a time.
  • Cross-layer coordination: Map UI, service, data, and external boundaries before changing code.
  • Incremental hardening: Add error handling, validation, edge cases, and tests in separate passes.
  • Use case: Ideal for features that span multiple systems, have unclear requirements, or need always-working increments during development.

Quick Start

Use the tracer skill to implement [feature] by mapping the path, shipping a thin end-to-end slice first, and then widening it pass by pass.

Frequently Asked Questions about tracer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is thin-slice delivery for cross-layer feature implementation?▼

Thin-slice delivery builds the smallest working end-to-end path first, proving cross-layer integrations work before widening the feature incrementally with error handling and validation.

How do I implement vertical slices that stay working after each increment?▼

Implement vertical slices using a bottom-up approach, shipping a thin end-to-end path first, then adding error handling, validation, edge cases, and tests in separate passes.

When should I use iterative implementation for feature delivery?▼

Use iterative implementation for high-risk integrations, cross-layer changes, unclear requirements, or vertical slices that must remain working after each development increment.

How do I handle error handling and validation in incremental feature development?▼

Handle error validation through phased widening, adding error handling, edge cases, and validation through tests in separate passes after the initial thin end-to-end implementation path works.

Does bottom-up implementation work for features with unclear requirements?▼

Bottom-up implementation works for unclear requirements by mapping cross-layer boundaries first, shipping a thin end-to-end slice, then widening incrementally with reportable commits documenting remaining work.

What is the best way to coordinate cross-layer changes without a big-bang deployment?▼

The best way to coordinate cross-layer changes is mapping UI, service, data, and external boundaries first, then building a thin end-to-end implementation path before widening one concern at a time.