---
name: check-ins
description: "Come back to what you left open, with messages you schedule: a deploy or a CI run, something you asked a person to do outside the board (an approval, a key, an install), something you said you'd do later. Says how often and for how long, what to do when one wakes you, and how to tell a thread that its news arrived somewhere else. Use before you end a turn with anything open, on every check-in that wakes you, on an app's message a thread may be waiting on, and when someone wants something on a repeat."
title: check-ins
canonical_url: https://skilld.dev/gh/vercel/board/check-ins
last_updated: 2026-11-19T06:15:42.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> If the user asked to install this Skill, run `npx skilld install vercel/board/check-ins`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/check-ins`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/vercel/board/check-ins) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/check-ins`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/check-ins --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/check-ins --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# Come back to what you left open

You only wake when a board message arrives. A deploy finishing, a person approving a request in a
dashboard, a key being added: none of those is a board message, so none of them wakes you. A
message you schedule does. It posts in the thread as you, later, and wakes you there.

## Before you end a turn

Something is open when the thread's people care how it ends, and its end won't be posted there:

- **Something that takes minutes:** a deploy, a CI run, a job you started.
- **Something you asked a person to do where you can't hear it happen:** approve a request, add a
  key or a permission, install an app, change a setting.
- **Something you said you'd do or look at later.**

A question you asked in the thread wakes you when it's answered. It's open only when the work
can't go on without the answer.

For each open thing, schedule its check-ins in that thread, then say in your reply, in a few
words, that you'll look again ("I'll check in a few minutes"). Nobody should have to come back
and tell you it's done.

```bash
vb schedule <id> "Check whether <what> happened: <how to tell>. Then <what's next>." --every 5m --times 3 --no-sync
```

- **Write it for a reader who remembers nothing:** what to check, how, and what comes next. By
  then this thread's session may be a new one.
- **`--no-sync` keeps it out of Slack.** A check-in is a note to yourself.
- **One set per open thing.** `vb schedules <id>` lists what's pending in the thread: don't add a
  second for the same thing.

## How often, and for how long

Each check-in is a whole turn of yours, and most find nothing. Ask for the fewest that still catch
it in time: often while it's likely to happen, rarely after that, and never without an end.

| Waiting on | Schedule |
| --- | --- |
| Minutes: a deploy, CI, a job | `--every 5m --times 4` |
| A person who's in the thread right now | `--every 5m --times 3`, and behind it `--in 1h --every 4h --times 3` |
| A person, whenever they get to it | `--in 1h`, and behind it `--in 1d --every 1d --times 3` |
| An answer the work can't go on without | `--in 1d`, once |
| A time you know: a retry on the 18th, a trial's end | `--at <that time>`, once |

These are where to start: go by how long this kind of thing takes here. A PR you opened has its
own, in the pr-lifecycle skill.

## When a check-in wakes you

Look at the thing itself, not the board: the service's API or CLI, `gh`, the deployment.

- **It happened:** do the next step if it's yours to do, say so in the thread in one line with
  what's next, and cancel what's still pending for it.
- **Not yet:** post nothing, and end your turn.
- **The last one, and still nothing:** say once where it stands and what it's waiting on, to
  whoever it's waiting on. Then leave it with them: schedule no more unless they ask. It's the
  last when `vb schedules <id>` shows nothing pending for it.
- **It no longer matters** (someone did it another way, the thread moved on): cancel what's
  pending.

```bash
vb schedules <id>               # what's pending in the thread
vb schedule cancel <schedule>   # each one that's settled
```

## When the news arrives somewhere else

Some of what you wait on does reach the board, in a thread of its own: an app's alert in a
mirrored Slack channel ("subscription canceled"), a PR's or an issue's thread from GitHub. Each
thread has its own session, so the you that picks it up doesn't know another thread was waiting
on it.

So before you answer an app's message, search your channels for what it names:

```bash
vb read <your channels>/ --text "<the ID, the email, the PR>"
```

When a thread was waiting on it, the news belongs there:

- **Reply in that thread** with what happened and what's next, as its check-in would have.
- **Cancel that thread's check-ins for it.**
- **On the app's message, leave a reaction, or one line that links that thread.** Whoever did it a
  minute ago doesn't need a report of it.

## On a repeat

A report or a sweep someone wants every morning, or every Monday:

```bash
vb schedule <channel> "<what to do, as a title>" --at <the first time, with its UTC offset> --every 1d
```

Each send starts a thread in that channel and wakes you there. These do reach Slack: people read
them.

- **Only what someone asked for.** When you think one would help, offer it, and schedule it on a
  yes.
- **One schedule per report.** `vb schedules --channel <channel>` shows what's already there.
- **At a time the team is around.** A send with nothing new says so in one line.
- **When nobody reads it any more, ask whether to stop it.**
