TRAINING · FRAME, PLAN, MAP THE TASKS
Frame, plan,
map the tasks.
Written down, before it is built.
From an idea to a Dev Ready project.
Frame
Plan
Map the tasks
Prototype
Start simpleWhat the skill doesThen you reshape
Three tiers. Five blocks.
| Developer | Senior Developer | Product Owner | |
|---|---|---|---|
| Owns | Tasks | A project | A product and its codebase |
| Client | In writing | Runs the meeting | Main contact, no founder needed |
| Direction | Receives and executes | Runs on what was sold | Pulls the product forward |
| Ships | Scoped work on time | The project, on appetite | Systems others use |
| Proof | Small project, reviewed | A quarter with no rescue | One system shipped, one project sold |
Last time: the Client block. Today: the Direction block.INOVO GROWTH TRACK · VERSION ZERO
A project starts as a conversation.
- The idea lives in a call, a Slack thread or your head
- The first week goes on working out what we are building
- Tasks appear as you go, so nobody can see the whole
- The client sees nothing until something is built
Running on what was sold starts with writing down what was sold.THE PROBLEM · DIRECTION
Four things. This is the pitch.
01
→
Frame
Problem, outcome, out of bounds, appetite. The promise.
02
→
Plan
The steps in order, exact enough for an agent to run.
03
→
Map tasks
Thin slices that ship on their own. One action per task.
04
Prototype
Mock the screen. The client sees it before they decide.
This is how we prepare the presentation to the client. We sell the idea with these.THE MAP · FRAME, PLAN, MAP, PROTOTYPE
Where this fits.
You are here
01
→
Framed
Frame, plan, tasks, prototype. The pitch.
02
→
Shaped
After approval: the details and the unknowns worked out.
03
→
Built
No build until payment. First version by mid-build.
04
Launch
Ship it. The last week is for fixes.
Framing prepares it. Shaping is the work. The client approves and funds between the two.THE PROJECT PROCESS · LANCE'S FOUR BLOCKS
The skill
One idea in. Dev Ready out.
inovo-new-project: your agent writes the project onto the dashboard.
What the skill does.
01Framing
- Writes problem, outcome, out of bounds and appetite
- Turns a solution you gave it back into the problem
- Runs the framing review and fixes what it flags
02Task grid
- Cuts vertical slices that could each ship on their own
- Slice 1 is the smallest thing that works
- One action per task, verb first, three to eight words
03Plan
- Saves the full plan on the project, written for an agent
- Exact file paths, tables, env vars and endpoints
- One section per slice, with how to know it works
04Prototypes
- A second prompt: one prototype per new screen
- Named and versioned on the project page
- The client reviews it before anything is built
Also creates the project in Notion, the dashboard and Toggl. Dev Ready, assigned, one run.INOVO-NEW-PROJECT · V1
The frame is the promise.
- Problem: the pain we can see, and why now. No solutions.
- Outcome: three to five things that will be true. Not a feature list.
- Out of bounds: the features and edge cases we are not doing, by name
- Appetite: the fixed time budget, and why it is worth that much
- Start with a solution and the skill asks what problem it solves
Money here. The client funds the frame, not the code.THE SKILL · 01 FRAMING
Thin slices. Tiny tasks.
- A slice ships on its own. Never "backend", "frontend", "testing".
- Slice 1 is the smallest thing that works
- A task is one action. Verb first, three to eight words.
- Needs a sentence to explain? Split it into two tasks.
- A human or an agent can take it without asking a question
SLICE 1Bot answers one question
Create DISCORD_BOT_TOKEN env variable
Add env variables to DigitalOcean
Register the bot with one command
Reply with a fixed answer
SLICE 2Answers from the Brain
Add brain_search to the handler
Format top result as the reply
Log each question to work log
SLICE 3Client channel
Write migration for allowlist
Add client channel to allowlist
Post release note to channel
Good: "Create DISCORD_BOT_TOKEN env variable". Bad: "Set up the integration".THE SKILL · 02 TASK GRID · SCHEMATIC
Verb first. Two lines, max.
Badly written tasks
- Set up and configure the Discord integration including OAuth, the webhook endpoint and error handling, then test it end to end with the client channel and document it
- Implement everything needed for notifications
- Make sure the dashboard works properly and fix any bugs you find along the way
Well-written tasks
- Create DISCORD_BOT_TOKEN env variable
- Add env variables to DigitalOcean
- Register the slash command with Discord
- Write migration for provider constraint
- Send one test message to the client channel
A paragraph in one task is AI slop. Human-readable, scannable in a second. If it wraps, split it.THE SKILL · 02 TASK GRID · GOOD AND BAD
A plan an agent can run.
- Context first: what the product is, what this project changes, why
- Exact names: file paths, table names, env vars, endpoints. Never "the config".
- One section per slice, in the same order as the grid
- Acceptance per slice: how we know it works
- Known gotchas and the docs to read, linked
Devin or Claude reads the plan cold. No extra context, no questions.THE SKILL · 03 PLAN
Mock it before you build it.
- Every new screen gets a prototype on the project page, before the pitch
- Ask your agent: "Prototype slice 1 as a single page"
- Prototypes are named, so one project can hold several
- Snapshot a version before you change it; the history stays
- The client reacts to the mock on the call, not to finished code
Cheap to change now. Expensive to change after the build.THE SKILL · 04 PROTOTYPES
Then you reshape
Simple first. Then reshape.
The first grid is a draft, not a contract.
Start simple. Reshape as you go.
- Run the skill with a plain paragraph. Do not polish the idea first.
- Read the grid once. Move tasks between slices as you learn the work.
- A slice grows past a few days? Split it.
- A task needs a question? Split it or write the answer into the plan.
- The grid is the live map. Done means shipped, slice by slice.
You own the shape. The agent owns the typing.RESHAPE · 1 OF 2
Live: one idea to Dev Ready.
- Say the idea in one paragraph. Name the client. Give an appetite.
- The skill shows the frame and the slices once. You approve.
- Then it writes everything to the dashboard in one run
- Open the project page: frame, grid, plan, status Dev Ready
Live demo, on a real idea. Watch the project page fill up.RESHAPE · 2 OF 2 · LIVE
The checklist.
Before
- Project name and client
- The idea in one paragraph
- An appetite in weeks
- Dashboard MCP connected
Check
- Problem has no solution in it
- Out of bounds names real features
- Slice 1 ships on its own
- Every task is one action
- Plan has exact paths and names
- Status Dev Ready, assigned
Then
- Prototype the first screen
- Present the page to the client
- Approved and funded? Shaping starts
- Reshape the grid as you learn
- Log your time
Take this one home. Run it on your next project.FRAME, PLAN, MAP THE TASKS · V1
Frame it
before you build it.
Run the skill on your next project.
Tell us in #team what it got wrong.
Frame.Plan.Map.Prototype.