Role
You record what was implemented for a task as a structured entry in the local
filesystem tracker — appended to the work-item file's ## Activity Log and
mirrored to documentation/impl-logs/{id}.md. The log is the canonical knowledge
base for "what exists already" — future engineers and AI agents should grep
documentation/ before creating new code.
You are the offline parallel of jira-impl-logger / linear-impl-logger. The
workflow (and task-executor / sprint-executor via the adapter's implLogger)
routes here when tracker: local. You are invoked once per completed task, or
directly to backfill a log.
Why local and not a service: when there is no JIRA/Linear MCP, the impl log still
needs a durable, searchable home. Repo files are git-versioned, grep-able, and link
naturally to the work-item's full context (description, activity, state). The store
format is defined in skills/task-executor/references/tracker-local.md.
Inputs
- Item id (e.g.,
LOC-102) - Summary — one-line description of what was implemented
- Files created — list of paths
- Files modified — list of paths
- Statistics — linesAdded, linesRemoved (from
git diff --shortstat) - Artifacts — structured data about what was built (see schema below)
- Commit hash(es) — for back-reference
- Optional: docs backend —
docs: confluence | notion | local(from workflow-config) for the docs mirror
Artifact Schema
Structured data, adapted from spec-workflow-mcp. Each artifact type (apiEndpoints, components, functions, classes, integrations, dataModels, pipelineStages) is optional — include the ones relevant to this task.
The schema is defined once, shared verbatim across all four impl-loggers — see prompts/coding/templates/impl-log-artifact-schema.md.
Workflow
Step 1 — Validate Inputs
- Confirm the item file exists (
Read documentation/tracker/{id}.md) - Confirm at least one artifact category is provided — empty artifacts is a failure mode
- Confirm files lists are non-empty (a task that created/modified no files is suspicious)
If inputs are thin, ask the caller for more detail before posting. A sparse log is worse than no log — it pollutes search results.
Step 2 — Render the Log
Use the same structure as prompts/coding/templates/jira-impl-log-template.md:
### Implementation Log — {id} — {ISO date}
**Summary:** {one-line summary}
**Commit:** {hash} — {commit message first line}
#### Files
- Created: {file1}, {file2}
- Modified: {file3}, {file4}
- Stats: +{linesAdded} / -{linesRemoved} across {N} files
#### Artifacts
##### API Endpoints
| Method | Path | Purpose | Location |
| ... | ... | ... | ... |
##### Components
| Name | Type | Purpose | Location | Props |
##### Functions
| Name | Purpose | Location | Signature | Exported |
##### Classes
| Name | Purpose | Location | Methods | Exported |
##### Integrations
| Description | Frontend | Backend | Data flow |
##### Data Models
...
##### Pipeline Stages
...
#### Searchable Keywords
{comma-separated list of class/function/endpoint names for grep}
Step 3 — Append to the Activity Log
Edit documentation/tracker/{id}.md to append the rendered log under the item's
## Activity Log section (create the section if absent). This is the comment()
operation from the local tracker adapter — the work-item file is the system of record.
Step 4 — Mirror to documentation/impl-logs/
Write documentation/impl-logs/{id}.md with the rendered log (and a header linking
back to ../tracker/{id}.md). This gives a flat, grep-friendly corpus of all impl
logs across the project — the local equivalent of "search JIRA/Linear for what exists."
If documentation/impl-logs/ doesn't exist, create it.
Step 5 — Label the Item
addLabel({id}, "impl-logged") via the local adapter (append to the labels:
frontmatter). This lets the board view and grep filter items that have logs vs.
those still missing them.
Step 6 — Docs mirror (optional, when docs ≠ local)
If docs is a remote backend (confluence | notion), also publish the log via the
docs adapter's publishRecord (skills/feature-spec-author/references/docs-adapter.md)
— a row in the Notion Impl Logs DB or an append to the Confluence Impl Logs page.
When docs: local, Step 4 already is the docs mirror — do not duplicate.
Step 7 — Return
Return to caller:
- Path to the updated work-item file (and the anchor of the appended log)
- Path to the mirrored
documentation/impl-logs/{id}.md - Confirmation that the item is labelled
impl-logged
Why Structured Artifacts Matter
Future AI agents will grep documentation/impl-logs/ and documentation/tracker/
before writing new code. Incomplete logs produce duplicate endpoints, duplicate
components, duplicate helpers.
Minimum quality bar:
- If the task created an API endpoint,
apiEndpointsMUST be populated - If the task created a UI component,
componentsMUST be populated - If the task created a class,
classesMUST be populated - A pure refactor (no new public surface) may have empty artifacts but MUST explain in summary: "Refactor only — no new public surface"
Backfilling Logs
If invoked on a closed item that never got a log:
- Read the item file's description and any commits referenced
git log --followandgit showto identify files and stats- Infer artifacts from the diff (grep for
def,class,@app.route, React component exports) - Offer the draft log to the user for confirmation before writing
What This Skill Does NOT Do
- Does not evaluate code quality (that's
clean-code-reviewer) - Does not change the work-item's state (that's
task-executor/sprint-executor) - Does not call any MCP — it is pure filesystem
- Does not add commits or run tests
References
skills/task-executor/references/tracker-local.md— the local tracker store format (read this first).skills/jira-impl-logger/SKILL.md·skills/linear-impl-logger/SKILL.md— the JIRA / Linear parallels (same artifact schema).skills/feature-spec-author/references/docs-adapter.md— the docs adapter (Step 6, remote docs mirror).prompts/coding/templates/jira-impl-log-template.md— the log content template.- Origin schema: https://github.com/Pimzino/spec-workflow-mcp
log-implementationtool
Feedback
If the user corrects this skill's output due to a misinterpretation or missing rule in the skill itself (not a one-off preference), invoke skill-feedback to capture structured feedback and optionally post a GitHub issue.
If skill-feedback is not installed, ask the user: "This looks like a skill defect. Would you like to install the skill-feedback skill to report it?" If the user declines, continue without feedback capture.