explain-code-slice

Explain Code Slice

Use this skill when the user wants one bounded walkthrough of how part of a system works from start to finish. The canonical term is slice.

Purpose

• Explain one slice end to end without dropping meaningful steps.
• When the user wants the slice recorded durably, preserve an existing repository-owned slice record or ask where it belongs.
• Start with the incoming data shape, what it represents, who sends it, and why it enters the flow.
• Walk the execution path in order, including boundaries, branch points, shared versus specialized steps, and data transformations.
• End with the final output shape, who receives it, and what purpose it serves.
• Let the user control explanation density with a detail level, not by silently skipping steps.

Canonical vocabulary

• slice: one bounded end-to-end walkthrough of a request, event, feature action, job, or data item.
• data shape: the meaningful structure of the data at a point in the slice, what it represents, and why it has that shape.
• boundary: a meaningful crossing such as caller/callee, module, package, process, service, client/server, queue, storage, or external API.
• branch point: any step that can route execution down different paths.

Treat pipeline, execution flow, request lifecycle, data flow, trace, and walkthrough as compatibility language for the same underlying workflow unless the user clearly means something else.

Inputs

• The slice subject:
  • a feature
  • a request or event
  • a job or workflow
  • a specific datum moving through code
  • a code entrypoint or path to follow
• Optional detail level:
  • quick
  • standard
  • thorough
• Optional focus:
  • branch-heavy
  • data-shape-heavy
  • boundary-heavy
  • debugging-oriented
• Optional comparison target for compare slices

Use standard when no detail level is specified.

Primary workflow: explain a slice

1. Identify the slice trigger or entrypoint.
2. Explain the incoming data first:
   • what shape it has
   • what it represents
   • who is sending or constructing it
   • why it is entering the slice
3. Walk the slice in strict execution order from start to finish.
4. For each meaningful step, explain:
   • where it happens
   • what responsibility it has
   • whether it is shared or specialized
   • whether it crosses a boundary
   • whether it branches
   • whether the data shape changes
   • why any transformation exists
5. End with the output or return path:
   • final shape
   • final destination
   • why that result is consumed there
6. Include a simple step diagram with markers for branch points and data-shape changes.
7. Add short notes for those markers so the diagram stays readable.