# Execution Slicer

> Slice a large idea, task, or plan into the smallest strong executable step. Use when the next move feels too big, vague, or risky, and when progress depends on shrinking scope without losing strategic value.

- Skill: `alubiama/execution-slicer` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add alubiama/execution-slicer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/alubiama/execution-slicer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: Alubiama (https://skillmd.com/u/alubiama)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/alubiama/execution-slicer

---


# Execution Slicer

## Goal

Shrink a big move into a minimal executable slice.

This skill does not replace planning. It makes the next step small enough to start and meaningful enough to matter.

## When To Use

- the plan feels too large to start
- the next step is vague
- the team is blocked by scope size
- a decision needs a first slice, not a full rollout

## Scope Boundaries

In scope:

- define the smallest valuable slice
- preserve the real objective while reducing scope
- name dependencies and blockers for the first slice

Out of scope by default:

- full roadmaps
- rescoping the whole strategy

## Escalation Conditions

Pause and return a narrower recommendation when:

- the outcome itself is still ambiguous
- the blocker is evidence or prioritization rather than slice size
- the minimum slice no longer tests or advances the real objective
- dependencies dominate so strongly that slicing alone will not unblock work

If slicing is not the main issue, recommend `intent-clarifier`, `priority-engine`, or `bottleneck-locator` instead of forcing a fake slice.

## Workflow

1. State the intended outcome.
2. Separate core value from optional complexity.
3. Identify the smallest slice that still tests or advances the objective.
4. Remove nice-to-haves.
5. Name dependencies for the slice only.
6. Define a concrete `start_trigger` and `completion_cue`.
7. Return the first executable step.

## Output Contract

Always return:

1. `intended_outcome`
2. `oversized_elements`
3. `minimum_slice`
4. `what_was_removed`
5. `slice_dependencies`
6. `why_this_slice_is_enough`
7. `start_trigger`
8. `completion_cue`
9. `recommended_followup`
10. `next_step`

## Guardrails

- Do not slice so hard that the objective disappears.
- Do not keep optional complexity in the first move.
- Prefer a testable slice over a polished mini-version.
- If the smallest valuable slice is still too large, say what upstream blocker must move first.
- Make the first slice easy to start and easy to recognize as done.

## Anti-Patterns

- fake slicing that keeps most complexity
- tiny busywork with no strategic value
- endless decomposition with no start