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.