Lanework Blog

Getting started with Lanework, with an agent

Lanework is a kanban app for the Mac. Its boards are plain folders of Markdown files, and the app is a live view of them.

That gives a board two ways in. You can work it by hand, in the app, the way you’d use any kanban board. Or you can hand it to an AI agent, which reads and writes the same files while you watch the cards move. Most people end up doing both, on the same board.

They’re two ends of the same pool, and it’s easier to get in at one of them. This post starts at the agent end: you’ll set up the skills first, and make and run a board from Claude Code. If you’d sooner learn the app by hand first, read Getting started with Lanework, by hand.

One thing before we start. Lanework is a beta, and the skills that drive all of this are younger and rougher than the app. I’ve written about that plainly in The skills are beta squared. The short version: do this in a git repository, and start on a project you can afford to experiment with.

What you need

Step 1: Install the skills

A skill is a set of written instructions that teaches an agent how to do something. The Lanework skills teach it what a board is and how to work one.

In Claude Code, run these two commands:

/plugin marketplace add https://github.com/laneworkapp/lanework-marketplace.git
/plugin install lanework@lanework

If you’d like to copy them from the app, they’re on the Welcome window under Add to Your Agent….

That’s the whole setup. There’s nothing to connect and no key to paste, because the agent never talks to the app. It only edits files.

Step 2: Ask for a board

Now ask, in plain words:

Set up a Lanework pipeline board for this project.

The agent may ask you a question or two, such as which labels you’d like. Then it creates the board as a folder in your project, at Lanework/<Project> Pipeline.lanework, and commits it.

Open that folder in Lanework: double-click it in Finder, or use File ▸ Open. You’ll see an empty board with its lanes in place.

Opening it matters. The first time Lanework opens a board, it adds a guide and a schema to the folder. The guide is what every agent reads before it touches the board, so let the app write it before you go further. The agent will commit those files too.

Step 3: Learn who moves what

A pipeline board carries work from a raw idea to a finished piece. The idea behind it fits in a sentence: a card’s lane says who acts next.

Lane Who acts
Ideas You. Anyone can file here, and you decide what goes forward
Shaping The agent. It turns a rough card into a proper proposal
Proposed You. Read the proposal, then approve it, bounce it or drop it
Approved The agent. A card here is your go-ahead to build
Active The agent. This is work in progress
Done Nobody. It’s finished

There are two more lanes, Issues and Tasks, for things that come in from the side.

The two “You” rows are the gates, and they’re the point of the whole design. Nothing gets shaped until you pick it, and nothing gets built until you approve it. An agent will bring a card to a gate and stop there.

Step 4: File some cards

Tell the agent what’s on your mind:

File cards on the pipeline board for these: the signup form loses what you typed when validation fails, we need a dark mode, and the footer links are out of date.

Watch the board. Three cards land in Ideas, one after another.

Open one. The body says what the card is for. In the comments beside it there’s a first note from the agent explaining why the card exists. Agents sign everything they write, so you can always tell their work from yours.

Step 5: Have something shaped

Pick the card you care about most and drag it to Shaping. That drag is the instruction. Then tell the agent to go and look:

Sweep the pipeline board.

The agent reads the board, finds your card in a lane that’s its to act on, and gets to work. It reads your code, works out an approach, and rewrites the card’s body into a proposal: what will change, how, and how you’ll know it’s done. Then it moves the card to Proposed and tells you what’s waiting for you.

Read the proposal. If it’s wrong, say so in a comment and drag the card back to Shaping. If it’s right, go on to the next step.

Step 6: Approve it, and have it built

Drag the card to Approved. Then:

Work the approved cards.

The agent moves the card to Active and builds it. It keeps a journal in the card’s comments as it goes: the plan, the decisions it made, the routes it didn’t take. When it’s finished, it moves the card to Done with a closing note saying what it ran to check the work and what that showed.

So the card ends up holding the whole story. The body is what was asked for, and the thread is how it went.

Step 7: Answer when it asks

Sooner or later an agent hits a decision that’s yours to make. It won’t guess, and it won’t bury the question in the chat. It posts the question on the card, addressed to you, and marks the card as waiting.

You’ll see a mark on the card’s face, and View ▸ Waiting on Me narrows the board to just those cards. Open one and the question is there, short, often with options to pick from. Click an option, or type a reply.

Answering on the card, not in the chat, is worth the habit. The answer stays with the work, where the next session will find it, whichever agent that turns out to be.

Agents address you by your handle. It defaults to your Mac user name, and you can change it in Lanework’s Settings.

Step 8: Leave it watching

So far you’ve told the agent when to look. You can also have it keep looking:

/lanework:watch

With one board in the project, that’s all you type. With several, name the one you mean. Now the session stays up and watches the board. Comment on a card and it replies there. Answer a question and it folds your answer into the card and carries on. Drag a card into Shaping or Approved and it starts, with no prompt from you at all.

This is the mode where the board starts to feel like a shared desk. You work in the app, and the agent keeps up from the terminal. Tell it to stop when you’re done. The watch also ends when the session does, so start it again next time.

There’s also an experimental /lanework:dispatch for a session you mean to leave running for hours. It does the same job and hands each change to a fresh helper, which keeps a long session quick. It may change or go away, so learn watch first.

Make the board yours

A board has a description, which you can edit in Board Settings. Anything below its first heading is your instruction sheet, and every agent reads it before it touches the board.

That’s where your rules go: what “done” means on this project, which command proves the tests pass, what an agent mustn’t touch. Each lane has a description of its own that works the same way. When an agent gets something wrong twice, a line there is usually the fix.

Where to go next

Start with one board and one card. Drag it to Shaping, and see what comes back.