Lanework is a beta. The skills are beta squared.
Lanework is in beta. You install it through TestFlight, things still change between builds, and some of them will break.
The Lanework skills sit on top of that. They are a second, younger project, built on a beta app and run by AI agents that don’t do the same thing twice. So I want to set expectations before you install them: the app is a beta, and the skills are beta squared.
This post explains what the skills are, why they earn that label, and how to use them anyway. I think they’re worth using. I also think you should know what you’re getting.
What a skill is
A Lanework board is a folder of plain files. An AI agent like Claude Code can already read and write files, so in principle it can already work a board. What it doesn’t have is the know-how: where a card goes, how to sign its work, when to ask you and when to carry on.
A skill is that know-how, written down. It’s a folder of Markdown instructions and a few small scripts that the agent reads when the task calls for it. There’s no server and nothing running in the background. The skills are open source, and you can read every word of them.
There are eight:
| Skill | What it does |
|---|---|
lanework |
The base: what a board is, how to read one, the rules for writing, new boards |
work |
Files and moves cards, writes comments, and builds what a board has approved |
watch |
Stays up, watches a board, and responds as you comment and move cards |
discovery |
Works through a project’s open questions with you, one card per question |
merge |
Resolves git conflicts on a board when two people have edited it |
heal |
Brings an older board up to date with the current format |
dispatch experimental |
The same watch for long sessions, handing each change to a fresh helper agent |
plan experimental |
Breaks a big idea into decisions and settles one per session |
They aren’t all at the same stage. Most are on the main track and close to settled. The two marked experimental, dispatch and plan, are still being tried out: they may change shape, merge into another skill or go away.
Installing them takes two commands in Claude Code:
/plugin marketplace add https://github.com/laneworkapp/lanework-marketplace.git
/plugin install lanework@lanework
Why beta squared
Four things stack up.
They follow a format that’s still moving
Every board carries a guide that the app writes, and that guide is the rulebook for editing the board’s files. It’s versioned, and the version climbs as the app changes. The skills are written against one version of it.
So each time the format moves, the skills have to catch up. Between a new build of the app and the skills release that follows, the two can disagree. There’s a rule for that, and it’s worth knowing: the board’s own guide always wins. A well-behaved agent reads the guide first and trusts it over anything a skill says. But “well-behaved” brings me to the next point.
They’re instructions, not code
The app is a program. Given the same click, it does the same thing every time, and when it doesn’t, that’s a bug I can find and fix.
A skill is prose that a language model reads and interprets. Most of the time the agent does what the skill says. Sometimes it skims, or improvises, or follows the letter and misses the point. The same request can go slightly differently on Tuesday than it did on Monday, and differently again on another model. I can make the instructions clearer, and I do with every release, but I can’t make them deterministic. Nobody can yet.
They act
A skill doesn’t only give advice. An agent using work creates cards, moves them and edits them. On a board with an approved piece of work, it will write code. watch and dispatch keep going until you tell them to stop, and they start helper agents of their own. Where the board lives in a git repository, the agent commits what it changed.
That’s the whole point, and it’s also the risk. A mistake in the app usually looks wrong on screen. A mistake by an agent can be a card filed in the wrong lane, a comment that says more than it should, or an afternoon of work built on a misread sentence. It also costs you real usage on your Claude plan, and a long watch can use a lot.
They change fast
The skills are at version 0.7, and the “0” is meant. New skills have arrived in most releases. Commands have been added and changed. Two skills have been renamed since the app’s own guide last described them, which tells you how quickly this is moving.
What works today may be spelled differently next month. I’ll keep the changelog honest, but I won’t promise stability I can’t deliver.
How to use them without getting hurt
None of that is a reason to stay away. It’s a reason for a few habits.
Keep the board in git. This is the big one. If a board lives in a repository, everything an agent does is a diff you can read and a commit you can undo. I wouldn’t point an agent at a board I couldn’t roll back.
Start on a board that doesn’t matter. Make a scratch board, or copy a real one, and try each skill there first. You’ll learn how an agent behaves on your boards in an hour, at no risk.
Start small. Install everything, but begin with plain requests: “file a card for this”, “what’s waiting on me?”. Leave watch and dispatch until you trust what you’ve seen. They never start by themselves: you have to type the command.
Read the trail. Agents sign everything they write, so you can always tell their work from yours. They also journal as they go, in each card’s comments. If something looks odd, the thread usually says what the agent was thinking.
Let /heal show you first. When a board falls behind the format, /heal lists what it would change and waits for you to say go. Read the list.
Answer asks on the card. When an agent needs a decision, it posts a question on the card and flags it as waiting on you. Answering there, not in the chat, means the decision is on the record for the next session.
Update on purpose. The plugin follows a stable branch that moves only when a release ships. Run /plugin marketplace update lanework when you’re ready for the new one, and skim the changelog first.
What you can count on
A few things aren’t beta squared, and they’re the reason the rest is safe to try.
Your boards are files. Nothing the skills do can lock them up or move them somewhere you can’t reach. If you remove the skills tomorrow, every board works exactly as it did.
The app doesn’t need the skills, and the skills don’t need the app to be running. Each one only ever touches the files.
And the guide in every board is the authority. It ships with the app, it’s tested with the app, and it’s the part an agent is told to believe.
Tell me what breaks
I use these skills on Lanework’s own boards, so I find a fair share of the problems myself. I don’t find yours.
If an agent does something surprising on your board, I’d like to hear about it: what you asked, what it did, and which model it was. Open an issue on the support page. Reports like that are how a skill gets from beta squared to plain beta, and one day past it.
Until then: back up, start small, and read what it wrote.