사용 방법
- 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
- 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
- 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/logbookfordevs/atlas-skills --skill tracking-implementation시작 전 확인
- 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
- 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.
Tracking Implementation
Keep execution state visible in an Implementation Record alongside the selected executor. The executor chooses and performs implementation work; Tracking records it and maintains the evidence, commit and acceptance contracts. Its Tracking Home is the source of truth for the implementation unit.
Activation
Activate when the user requests tracking, or resumes an existing tracked implementation from a ticket, spec, plan, prototype, prompt, or conversation. Read every source the user provides before shaping the implementation.
If the user asks to resume tracked implementation, use resume.md.
Skip tiny one-shot edits unless the user asks for tracked implementation.
Optional Audit Trail
For an explicit Audit Trail or Show Me Your Work request, read and follow Audit Trail. Resume it when the active record already selects it. Ordinary tracking uses no separate decision log.
Artifact presentation
Create new local Implementation Records as HTML unless the user explicitly requests Markdown or another format. When resuming an existing record, retain its format unless the user requests a conversion.
Before creating or updating the Implementation Record, read and follow Show Me. Let it organize the artifact around the work being tracked, choosing representations that make changes, evidence, review findings and continuation context easy to inspect. The record fields below define required content; use them within the chosen presentation rather than as a repeated prose template. Preserve structured state and complete, inspectable evidence within the selected Tracking Home; secondary views follow its synchronization agreement. Use the host’s available file-opening mechanism for HTML artifacts. Distinguish explanatory sketches from verified runtime results.
Implementation Records
Start with one Implementation Record. It persists across sessions, compactions, and handoffs; do not create one record per session.
Split only when the work has independently owned, validated, or reviewed implementation slices. Each implementing agent owns one record and its directly relevant handoff notes; research and review agents report into the record they support.
Default new Tracking Homes to local records without asking. Use a remote mechanism only when the user requests remote tracking. When resuming, retain the existing Tracking Home unless the user requests a move:
- Local (default): create one Implementation Record in the format defined by Artifact presentation, following the repository or user storage convention. Let Show Me guide its layout and representations for the work and review needs; retain the chosen record across updates.
- Remote (on request): inspect the available mechanism and agree where status, execution evidence, review state, findings, and handoff notes will live.
An existing remote ticket may host the record when remote tracking is chosen. Otherwise keep the source artifact unchanged and reference it from the Implementation Record. Treat secondary representations as references unless the user agrees to a synchronization contract.
Keep local Implementation Records outside agent-created commits unless the user or repository convention explicitly opts them in. Remote tracking remains external to Git unless a local counterpart is selected.
The selected Tracking Home is the only required tracking artifact by default. Selecting Audit Trail adds its linked canonical decision log as evidence; execution state remains in the Tracking Home.
When parallel implementation needs separate worktrees, prefer yggtree when available before falling back to native Git worktree commands.
Active Implementation
Choose the active record in this order:
- The Implementation Record explicitly named by the user.
- Any record marked
in_progress,validating, orreview. - The pending record selected by the user or executor.
- A new record shaped from the provided source.
Before starting, read blockers and previous Continuation Context when they affect the active implementation.
Implementation State
Keep this state in the selected Tracking Home. For HTML, embed the fields in a labeled JSON block and expose their current values in the visible record. Markdown records use equivalent frontmatter; remote trackers use equivalent fields. The state schema is:
{
"id": "<scope-or-slice-id>",
"title": "<Implementation title>",
"status": "in_progress",
"blocked_by": [],
"source": "<artifact-or-issue-reference>",
"review_base": "<commit recorded before implementation>",
"updated_at": "2026-06-15T16:40:00-03:00",
"review_gate": "pending"
}Statuses: pending, in_progress, validating, review, blocked, done.
review_gate uses pending, changes_requested, awaiting_acceptance, and accepted:
pending: the selected automated reviews have not completed.changes_requested: the latest review has findings being judged or fixed.awaiting_acceptance: selected reviews are complete or have recorded coverage gaps, findings are resolved, and warranted fixes are validated and committed; the gate awaits the user's final judgment.accepted: the user accepted the checkpoint.
Keep the implementation status review until the review gate is accepted. Preserve the automatic review under ## Complete Review Record:
- For actionable findings, preserve the complete review output plus the judgment and resolution for each finding.
- For clean reviews, keep a compact receipt for each selected method with its scope, reviewed revision, finding counts, coverage gaps, and
awaiting_acceptancegate state. Preserve finding counts per Standards and Spec axis.
Use blocked_by for record dependencies, human decisions, missing context, or external blockers.
Execution Evidence
Record the selected execution bundle before implementation begins: TDD or Source-Driven Development through Engineering Principles, independent doubt-driven-development, normal project validation, or a combination.
Use Engineering Principles's TDD method when the implementation has a meaningful public Test Seam. Treat a seam approved in the source as pre-agreed. If the seam is missing, ambiguous, or invalidated by codebase evidence, agree on it with the user before writing tests. Use normal validation with an explicit skip reason when no meaningful executable seam exists.
Before moving an implementation to review, record evidence for each selected discipline:
- TDD: failing-test evidence before implementation when practical, then the passing run after implementation. If literal test-first was skipped, record why and the nearest proof used.
- Source-Driven Development: official docs or primary sources consulted, version signals checked, and source-backed implementation decisions or unresolved gaps.
doubt-driven-development: fresh-context adversarial review result, findings reconciled, and unresolved concerns escalated.- Normal validation: tests, typechecks, lint, builds, runtime checks, browser checks, or a clear reason a check could not run.
Do not mark the implementation review while selected discipline evidence is missing without an explicit skip reason.
During implementation, run focused tests and relevant typechecking. Run the complete relevant validation before review, or record the strongest available substitute.
Green Atomic Commits
Record HEAD as review_base before editing. Keep it unchanged for any later user-requested review.
Forward local commits are authorized, not mandatory. Create a green atomic commit when a durable checkpoint improves the work.
Commit all implementation-owned changes before opening the automated Review Gate. When the user would benefit from reviewing a small or judgment-sensitive change first, hand off for pre-commit user review instead.
History rewrites and remote or public actions still require approval. If local commits are unavailable, ask.
Review Gate
After final validation, run atlas-review once automatically for implementation-owned changes from review_base. Supply the checkpoint revision, originating intent, Tracking Home and existing validation/review evidence. Atlas Review owns method selection and execution; reuse adequate evidence for the same checkpoint and question. Record the methods actually selected, their review questions, scopes, findings and coverage gaps in Complete Review Record, keeping each method's output distinct.
If any selected review reports findings, set changes_requested; judge each finding against the implementation and its cited evidence, fix warranted findings, record evidence for dismissals, revalidate, and commit. Do not rerun the reviews automatically. Set awaiting_acceptance only after every selected review has completed and its findings are resolved, or its unavailable coverage has an explicit recorded gap. The user decides whether fixes or later changes require another review.
When the gate first reaches awaiting_acceptance, use Plannotator's available skills and tool guidance to launch an interactive review of the final implementation-owned diff from review_base (plannotator review --base <review_base>). Approval of the identified checkpoint sets accepted. Change requests set changes_requested and return to implementation. Closing or dismissing the review, or receiving no reply, leaves acceptance pending.
After resolving that review session's outcome, use Plannotator to annotate the implementation record when the Tracking Home is a local file, and reconcile its feedback before final handoff. If Plannotator is unavailable, record the gap, recommend installing it and continue the normal handoff with acceptance pending until explicitly given.
Review ownership: when Plannotator directs a delegated agent to report to its parent, hand off the Tracking Home, worktree, review_base and checkpoint revision. The parent able to host the session owns this gate's interactive review and record annotation, keeps the session alive, records feedback and delegates requested changes back to the implementer. Record the pending owner and next action in Continuation Context. The implementer remains responsible for validation and automated reviews.
Implementation Record
Keep task-local state in the Tracking Home using these content groups, or equivalent tracker fields:
- Source links: reference the authoritative scope, acceptance criteria, parent and story coverage instead of copying them. When no accessible source supplies this information, write the agreed scope and acceptance criteria in the record, plus any missing source context. Record local deviations and coverage gaps.
- Structured state: preserve the Implementation State schema for identity, status, blockers, review baseline and gate; add explanations where needed.
- Changes and Decisions: material changes, reasons, implementation-specific invariants, deviations and important constraints.
- Execution Evidence: selected execution disciplines with their required proof, actual validation runs and results, and explicit gaps or skip reasons. Apply the Execution Evidence requirements above.
- Complete Review Record: the full actionable review output, judgment and resolution for every finding, dismissal evidence, unresolved items, or the clean-review receipt defined above.
- Acceptance Journey: hands-on inspection guidance when product or design acceptance needs it; follow Review Guides.
- Continuation Context: recovery context and information needed by downstream tickets, including after this implementation is accepted and done.
These groups define required information when relevant, not a fixed heading or presentation template.
Record material deviations, assumptions, trade-offs, scope changes, surprising constraints, reviewer context, and next-agent context in the relevant Implementation Record. If a note belongs to a later slice, put it in that record's Continuation Context.
Before final handoff after implementation or review fixes:
- Record a note for non-obvious behavior invariants.
- Create or update an ADR for reusable policy, ownership, shared component, integration contract, data/model, migration, or long-term product decisions.
- Record material simplification opportunities and offer
code-simplification; do not silently refactor outside the checkpoint scope.
When implementation changes user-facing behavior, copy, or workflow, or acceptance needs visual judgment, follow Review Guides.
Operating Loop
- Read every provided source and resolve the implementation scope.
- Create or select one Implementation Record and choose its local or remote Tracking Home.
- Split into additional records only for independently owned, validated, or reviewed slices.
- Read blockers and relevant previous handoff notes.
- Record the execution bundle and confirm its Test Seam or skip reason.
- Mark the active implementation
in_progressbefore editing. - Before editing, adopt a comment-free default: express intent through names, structure, and types; every new comment must preserve enduring, non-obvious code behavior.
- Implement one green behavior slice at a time, creating atomic checkpoints when useful.
- Record important scope changes, working set changes, and blockers as they happen.
- Move to
validating, run the complete relevant validation bundle, and record discipline evidence. - Commit remaining implementation-owned changes, or hand off for pre-commit user review.
- Once implementation-owned changes are committed, move to
reviewand run the Review Gate workflow. - Run the checkpoint-notes/ADR check before final handoff.
- Move to
doneonly after the review gate is accepted. - Update the Tracking Home's modification signal whenever its record changes.