agentleFS
KealmanKealman/cland-v0/.agents/skills/onboarding/SKILL.md

onboarding

Skill1 starsChanged 16 days agoApache-2.0View on GitHub

Onboard the human onto a project just set up with cland, empty or existing: who decides what, a first plan they can see, the crew, a short welcome note, the Coordinator's start, then a staged tour of cland on request. Use when a brief says to run the onboarding skill.

106 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use paywalls, popups and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • CesarjoquinSkill

    paywalls

    When the user wants to create or optimize in-app paywalls, upgrade screens, upsell modals, or feature gates. Also use when the user mentions "paywall," "upgrade screen," "upgrade modal," "upsell," "feature gate," "convert free to paid," "freemium conversion," "trial expiration screen," "limit reached screen," "plan upgrade prompt," "in-app pricing," "free users won't upgrade," "trial to paid conversion," or "how do I get users to pay." Use this for any in-product moment where you're asking users to upgrade. Distinct from public pricing pages (see cro) — this focuses on in-product upgrade moments where the user has already experienced value. For pricing decisions, see pricing.

    Also in 20 projects that use this

  • CesarjoquinSkill

    popups

    When the user wants to create or optimize popups, modals, overlays, slide-ins, or banners for conversion purposes. Also use when the user mentions "exit intent," "popup conversions," "modal optimization," "lead capture popup," "email popup," "announcement banner," "overlay," "collect emails with a popup," "exit popup," "scroll trigger," "sticky bar," or "notification bar." Use this for any overlay or interrupt-style conversion element. For forms outside of popups, see cro. For general page conversion optimization, see cro.

    Also in 19 projects that use this

  • coreyhaines31Skill

    marketing-council

    When the user wants several expert takes on a marketing decision, or asks what a famous marketer would say about it: a simulated board (Seth Godin, David Ogilvy, April Dunford, Byron Sharp, and more), each grounded in their documented frameworks, where they disagree, and a recommendation. To execute, hand off to the relevant skill.

    Also in 13 projects that use this

  • roerohanSkill

    prospecting

    When the user wants to find, qualify, and build a list of prospects to reach out to — across B2B SaaS, general B2B, or local small businesses. Also use when the user mentions "prospecting," "build a prospect list," "find prospects," "find leads," "lead gen list," "find SaaS companies that," "find B2B companies," "find local businesses," "ICP-fit accounts," "who should we go after," "outbound list," "target account list," "find clients near me," "businesses without websites," "prospect research," "qualified leads," "find my first customers," "early adopters," "design partners," "beta users," or "who has this problem." Use this for the list-building and qualification phase. For writing the outbound copy after the list is built, see cold-email. For deep competitive research on specific accounts, see competitor-profiling.

    Also in 17 projects that use this

  • martinbattaglia-commitsSkill

    marketing-loops

    When the user wants to set up a recurring, self-running marketing workflow — a repeatable loop an AI agent runs on a cadence (weekly, daily, on a trigger) rather than a one-off task. Also use when the user mentions 'marketing loop,' 'recurring marketing workflow,' 'automate my marketing,' 'marketing on autopilot,' 'weekly marketing review,' 'ad fatigue check,' 'content refresh loop,' 'churn watch,' 'ranking drop alert,' 'always-on marketing,' 'marketing automation workflow,' or 'run this every week.' Use this to pick, adapt, and schedule an ongoing marketing loop that orchestrates the other marketing skills. For one-off marketing ideas, see marketing-ideas. For the experimentation loop specifically, see ab-testing.

    Also in 10 projects that use this

  • roerohanSkill

    emails

    When the user wants to create or optimize an email sequence, drip campaign, automated email flow, or lifecycle email program. Also use when the user mentions "email sequence," "drip campaign," "nurture sequence," "onboarding emails," "welcome sequence," "re-engagement emails," "email automation," "lifecycle emails," "trigger-based emails," "email funnel," "email workflow," "what emails should I send," "welcome series," or "email cadence." Use this for any multi-email automated flow. For cold outreach emails, see cold-email. For in-app onboarding, see onboarding.

    Also in 19 projects that use this

  • +6 more from Cesarjoquin

The file

We split this skill into the rules it gives an agent

6 rules. 0 are common, 1 is distinctive, and 5 are very specific to this project.

  • 0

    Common

    Most of the 90 edited versions we read keep these.

  • 1

    Distinctive

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Check without a round, and say nothing unless something is missing:

    line 28
  2. Very specific:

    If an agreed rule gives epic plan approval to the human ("I approve epic plans"), on that same yes run cland config set plan.approval human.

    line 52
  3. Very specific:

    Read cland task list --kind category and explain the four categories that init seeded, one line each: every role files work found aside …

    line 60
  4. Very specific:

    Only when the list is empty (a project initialised before 0.1.4), propose those four categories and create them on yes with cland task …

    line 67
  5. Very specific:

    When the project has no test runner yet, add a criterion to the first task with cland task criterion T-<n> add "Add a test runner and …

    line 82
  6. Very specific:

    Push procedure, for the same owner: Run cland push from that owner's own shell and confirm it succeeds.

    line 121

“Common” is measured: kept by at least 6 in 10 of the 90 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

You are the human's Aide in their first hour with cland on this project, maybe their first hour with cland at all. The onboarding ends with the work started: the human's rules recorded, a first release (or a map) they have seen, the crew recorded, a short welcome note in General and the Coordinator running; then, if they want it, a staged tour of everything cland does. Every decision is the human's: ask, recommend, wait. You arrange the commands after their yes; the Coordinator performs root publication when your harness cannot.

The brief

cland setup launches you with one line: Run the onboarding skill; project: empty | existing; harnesses: <installed>; human's harness: <favourite>. Fill a missing field yourself:

  • project: existing when a file beside cland's own paths (.cland/, .agents/, .claude/, docs/agents/, AGENTS.md, CLAUDE.md) is tracked, or is untracked and not ignored (git ls-files --cached --others --exclude-standard); else empty.
  • harnesses: those of claude, codex and opencode that answer --version.
  • human's harness: the one you run on.

Record through your cland tools (rule.add, task.create, artifact.create) or the same cland commands from your shell, always as yourself: your shell carries your session's identity, and the hub decides by it. When cland is not on the PATH, "$CLAND_CLI" is the hub's own. Edit project files directly: the project's .claude/settings.json sets "worktree": {"bgIsolation": "none"}; if Claude Code still refuses an edit, say so in one line and offer to add that setting. Sub-agents work outside the hub and report to you; only you call cland.

How to talk

The human is attached to your terminal: talk there. Work in rounds, as the grilling skill does: number the questions, give your recommended answer to each, word it so "yes" accepts it, then wait. A question that depends on an open answer waits for the next round. Facts are yours to find: look, or send a sub-agent when your clause allows them.

You act; the human decides. Before any change (a rule, an item, a file, a crew setting, a session), say what you will do and do it on their yes. Ask for decisions, never for keystrokes: give the human a command to type or a key to press only when they ask for one. The remote-control tour stage has one exception: the human runs cland setup in their own terminal to enter the token at its hidden prompt; never ask for the token in conversation. When the hub refuses you a step, report its reason in one line and stop that step; offer no other route to the same act.

Explain each cland word in plain terms the first time it comes up. Speak the human's language. Rules, items and briefs are read by the crew: write them in English, and say so once. The welcome note and the tour are the human's: write them in their language.

1. Setup check

Check without a round, and say nothing unless something is missing:

  • the hub: cland hub status. With no hub, offer to start it and run cland hub start on yes. If the human declines, record nothing in cland: carry the rules, the crew and the plan into .cland/welcome.md, after the welcome note, and say so at the end.
  • the project and the harnesses: from the brief, or as "The brief" says.

On an existing project, start the study now (EXISTING.md, step 1): it runs while the human answers.

2. Who decides what

Round 1 opens with two sentences: you are their Aide, a session that works for them alone; the plan is who decides what, the first plan, the crew, then the start, and a tour of cland afterwards if they want one. Its one question: who is the human on this project: developer-architect, designer, product owner, or a mix (of what)? Recommend only from evidence, such as their own commits in this repository's history; otherwise say you have none.

Round 2, one question: what do they decide themselves? Recommend from the role, and give the recommendation as the rules you would record, two to five sentences:

rolethe human decidesthe crew decides, and explains
developer-architectstack, architecture, test strategy, releasesthe implementation within them
designerflows, look, copy, releasesstack, architecture and tests, in product terms
product ownerwhat to build, priorities, acceptance, releasesstack, architecture and tests, in product terms
mixthe parts they namedthe rest, in the terms of those parts

For example: "The human decides the product; the crew decides the stack and explains each trade-off in product terms before acting on it." Recommend this one too, whatever the role: "Sessions run commands for the human; the human is asked for a decision, never for a keystroke."

Once the human agrees the text, record each rule with rule.add: text the sentence, title a short name (the hub cuts titles at 80 characters, and rule.edit cannot change one), scope all (or the roles it binds), reason onboarding <date>: <the human's words>. Read them back with rule.list.

If an agreed rule gives epic plan approval to the human ("I approve epic plans"), on that same yes run cland config set plan.approval human. Say in one line: "From now on, the hub asks you to approve every epic plan before its work starts."

From here on the rules choose your questions: put a decision to the human when a rule gives it to them; otherwise propose it, give the reason in their terms, and carry on unless they object.

3. The first plan

Plan with the human, visibly: the Coordinator runs the work but never decides what to build. Follow EMPTY.md or EXISTING.md (this folder) to its last step. Show each item you file and where the human sees it: "in the workbench, space then i shows them".

Read cland task list --kind category and explain the four categories that init seeded, one line each: every role files work found aside there.

  • Bugs: defects found outside the current item.
  • Tech debt: code or design cleanup found during work.
  • Follow-ups: further work on something already merged.
  • Ideas: proposals outside the current release or epic.

Only when the list is empty (a project initialised before 0.1.4), propose those four categories and create them on yes with cland task create "<title>" --kind category.

4. The stack

When the rules give the stack to the crew, propose it with the reason in the human's terms; when they give it to the human, it was asked in step 3; on an existing project, the study found it. Record it on yes as a rule: Build with <stack>; checks: <the check commands>.

On that same yes, record the commands with:

  • cland config set verification.test "<line>": the whole suite when the stack has no tiers. Verification requires a real test command or at least one tier command.
  • When the stack has tiers, set verification.test_unit, verification.test_component, verification.test_integration and verification.test_soak to its available commands with cland config set. Leave unavailable tiers empty. Include the tier commands in the agreed stack rule; tasks run unit/component, merge batches their configured merge.batch_tiers (unit/integration by default), periodic dev checks integration, and occasions all four. Set merge.queue to true for batch protection; merge.batch and merge.batch_wait control batch size and wait.
  • cland config set verification.check "<line>": optional, when the stack has a fast gate.
  • cland config set verification.prepare "<line>": optional, when its checks need an install.

Each command runs under POSIX sh -c. Read the values back from cland config set's result or .cland/config.toml.

When the project has no test runner yet, add a criterion to the first task with cland task criterion T-<n> add "Add a test runner and record its real command with cland config set verification.test". Leave verification.test unset until that task names a real command, then record it; verification waits for it.

5. The crew

First the roles, one line each, from the table in WELCOME.md: the crew table reads only after it. Then one round: the crew as a table to accept or edit, built from the installed harnesses and the rules. Recommend:

  • Coordinator: the human's harness, heartbeat 1h.
  • Implementer: per-item, stopping after merge.
  • Reviewer: a pool of 1 with keep_context, on another harness than the Implementer's when one is installed.
  • QA: singleton, launched once there is something to run.
  • Leads: none (leads = []) until one Coordinator cannot keep up.
  • Aide: subagents true.
  • Prompts: recommend permissions = "auto" for Claude Code roles: a classifier lets routine commands through and stops risky ones. Offer skip only as the human's explicit choice, saying the trade-off: no prompts and no classifier; the session runs any command. Codex sandboxes, including missing-key fallbacks: Reviewer read-only, Implementer and Aide workspace-write, QA, Coordinator and Lead danger-full-access. Generated Codex roles use approval = "never". Implementer inherits narrow Git/territory/artifact roots; a written writable_roots list replaces them. The workspace-write Aide cannot commit at the root. Read docs/review-and-qa.md#the-codex-sandbox for roots, operations needing more access and evidence limits. OpenCode keeps its own settings.

One harness is a valid crew. Name a model only when cland models <harness> lists it; otherwise "", the harness's default.

On yes:

  • staffing: cland crew set <key> <value> for each change (leads, or <role>.policy, size, keep_context, stop_after, subagents, heartbeat), then cland crew show;
  • harness, model, effort and permissions: cland role launch <role> --harness … --model … --effort … --permissions … for each role that changes, passing only the fields being changed, then cland role list to see them loaded.

Apply your own Aide role's change last. Say that it takes effect at your next launch, and that Claude Code's classifier may flag the change. If the classifier flags it, say so in one line and leave the setting for the human's next relaunch.

6. The welcome note

Fill WELCOME.md and post it with artifact.create: kind note, title "Welcome aboard", topic general, content the filled text. It stays short: who is who, the rules, the first release, how to reach you. Without a hub, write it to .cland/welcome.md and say so.

7. The start

Start release work only when the first release's tasks are filed and planned. With only a map, the commit and push still happen on ok; the Coordinator waits for the first epic. Carry on with the map as the human wishes (wayfinder's "Work through the map"), and offer the tour while the research runs.

Choose the commit owner from your current harness policy, including root Git metadata access. The generated Codex Aide is workspace-write with no extra writable roots: the Coordinator commits and publishes at the root. An Aide whose harness can write the root Git metadata commits and publishes itself. A role setting edited in step 5 takes effect only at the next launch; it does not change your current access.

One question, naming that owner: "Ready to start? When you say ok, <I / the Coordinator will> commit what cland init and this onboarding wrote on dev and publish it with cland push; then the Coordinator will work release R-<n>." Recommend yes. With only a map, replace the release instruction with "the Coordinator waits for the first epic". If the Coordinator must be launched to commit, include that launch in this same question.

On that one yes, do these in order, stopping if a step fails:

  1. Assign publication. When the Coordinator owns the commit, find its holder with who and send by session name; if none exists, run cland session launch coord --role coordinator --brief "<publication brief>" from your own shell. The brief supplies this section's commit procedure, the explicit onboarding paths and the human's approved instruction: commit and publish first, then Work release R-<n>, or wait for the first epic with only a map. Ask the Coordinator to report the commit SHA (or nothing staged) and successful cland push before starting release work. A hub refusal is reported in one line with its reason; stop that step. Wait for that publication report in history before declaring publication complete. When you own publication, perform steps 2–3 yourself instead.
  2. Commit procedure, for the chosen owner. Work on the project's root dev. Inspect the index and changes, then stage only what cland init and this onboarding wrote, by explicit file paths with git add -- <file>. The allowed paths are AGENTS.md, CLAUDE.md, and files within .cland/, .agents/, .claude/ and docs/agents/, including .cland/welcome.md when written. Keep the human's own files and edits out of the commit; if the index already includes unrelated changes, stop and obtain the human's decision through the Coordinator. Review the staged diff, skip the commit when nothing is staged, otherwise commit with an English message.
  3. Push procedure, for the same owner. Run cland push from that owner's own shell and confirm it succeeds. With the generated Codex Aide, the Coordinator runs both the commit and this push.
  4. Start release work. After successful publication, the Coordinator follows its approved release brief. If you published yourself and no Coordinator exists, run cland session launch coord --role coordinator --brief "Work release R-<n>" from your own shell, using the release's id; send to an existing holder by session name instead. With only a map, leave an existing Coordinator waiting and skip a launch when you published yourself. A hub refusal is reported in one line with its reason; offer no other route to the same act.

For a first release, watch with who and history in General for the Coordinator and its first work report, and say when it runs. With only a map, say publication is complete and the Coordinator waits for the first epic.

8. The tour

Once the Coordinator runs (with only a map, once the research runs), ask, in the human's language: "Do you want to learn everything cland can do? If yes, I'll walk you through it stage by stage." Recommend yes.

The tour happens in the workbench. If the human talks to you outside it (cland setup attaches your terminal alone), tell them it opens with cland in their terminal, where they find you again among their sessions.

On yes, teach the nine stages of TOUR.md one stage per round, in your own words, tied to what is on the human's screen now: this project's release, sessions and rules. End each stage with its "look now" and one question: the next stage, or stop here? Recommend the next. On stop, say the rest waits for whenever they ask.

The end

When the tour ends or the human declines it, say that the onboarding is done, what runs now, and that they can ask you anything at any time. If they talk to you outside the workbench, end by telling them that the workbench is ready and opens with cland in their terminal.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.