A task that says "implement the feature" is not a task, it is an intention. When a job seems too big to start, the problem is usually not the volume: it is that nobody has decided the first step that can be verified.
The planning process
1. Plan before touching anything. The initial phase is read-only: you read the specification and study the existing code, changing nothing. The plan comes from what is there, not from what you imagine.
2. The dependency graph. You identify what depends on what. The foundation comes first (data schema, types, interfaces), then what uses it. The order of work follows the dependencies, not the order in which the ideas came.
3. Vertical slices. The work is divided into slices that cut through all the layers and produce something that works, not into horizontal layers ("first all the database, then all the interface"). A vertical slice can be tried and shown; a layer alone cannot. If a task takes six weeks to show a result, the breakdown is wrong.
4. Writing the tasks. Each has a descriptive title, the acceptance criteria (how you know it is finished), the verification (which test or check proves it), the dependencies and the files touched.
5. Ordering and adding checkpoints. After each group of tasks there is a check: does everything work together? Can it be shown? If the answer is no, you do not go on.
How big a task should be
Small enough to be completed and verified in one working session, big enough to make sense to whoever receives it. A useful sign: if the title contains "and", it is probably two tasks. A plan in which every task is "big" has postponed the breakdown, not done it.
The plan document
A well-made plan has: an overview, architectural decisions, the list of tasks grouped by phase (foundations, main features, polish), a checkpoint after each phase, risks with their mitigation, open questions and the tasks that can be done in parallel by different people.
The most common excuses
| Excuse | Reality |
|---|---|
| "I'll write it as I go" | Without a list you do not know whether you have finished, and nobody else can help you. |
| "Dependencies show up along the way" | They show up late, when the wrong order costs a rework. |
| "Checkpoints slow things down" | They slow things down less than an error found at the end. |
Warning signs
- You start building without a written list of tasks.
- Tasks that say "implement the feature" with no acceptance criteria.
- No verification in the plan.
- All the tasks are big.
- No checkpoint between tasks.
- The order of dependencies was not considered.
An example
You have to build a room-booking module. A layered breakdown ("database, then API, then screens") shows nothing for two weeks. A vertical-slice one: first "book a room for an hour, with no checks" (from the database to the screen), then "prevent overlaps", then "cancel". Each slice is shown to a user the day it is finished.
When to use it
When there is a specification or clear requirements and you need to turn them into executable work, when a task seems too big to start, when you need to estimate the scope or when work can be done in parallel.
This method derives from the open-source agent-skills family by Addy Osmani (MIT licence), rewritten and adapted.
This article is an OIAR skill
What you have just read is the content of a skill from the OIAR catalogue, written for people. Knowledge like this, but richer and deeper, written for the agents, drives the interviews, the analysis and the report inside the platform. Skills are used in OIAR: to try this one on a project of yours you need an account.
planning-and-task-breakdownA method for turning a specification into a plan of verifiable tasks: read-only study, dependency graph, vertical slices, tasks with acceptance criteria, sizes, order and checkpoints. Use it when a specification or clear requirements exist and a job seems too big to start.