New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Setup Routines

by Yesterday-AI in Yesterday-AI/paperclip-plugin-company-wizard

Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers.

MITAuto-check passedBackend & APIs

Install Setup Routines

skills CLI
$ npx skills add Yesterday-AI/paperclip-plugin-company-wizard --skill setup-routines -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Yesterday-AI/paperclip-plugin-company-wizard setup-routines --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Yesterday-AI/paperclip-plugin-company-wizard.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/setup-routines .claude/skills/setup-routines && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
setup-routines
GitHub stars
186
Token cost
~3.1k tokens
SKILL.md length
917 words
Files
1
Skills in repo
4
Repo updated
First seen
Licence
MIT

At a glance

Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers.

  • Works in 5 steps: Company Health Snapshot → Issue Archaeology → Agent Diagnostics → …
  • Setting up routines for a new
  • SKILL.md covers Analysis Framework, Routine Design Rules, Provisioning Procedure and Routine Description Best…, plus 5 more sections
  • Calls curl and jq; needs PAPERCLIP_API_KEY

What it does

Setup Routines is an agent skill from Yesterday-AI/paperclip-plugin-company-wizard. Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers. Replaces expensive always-on heartbeats with targeted, data-driven scheduled runs. Use when setting up routines for a new or existing company, or when optimizing token spend on agent heartbeats.

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Scheduled and recurring tasks and Webhooks. The repository describes itself as: Bootstrap AI agent companies from modular templates. The licence is MIT.

When your agent uses it

  • Setting up routines for a new
  • Existing company
  • Optimizing token spend on agent heartbeats

Example prompts

  • “/setup-routines”

Requirements

  • Python 3
  • A credential in PAPERCLIP_API_KEY

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Company Health Snapshot
  2. Issue Archaeology
  3. Agent Diagnostics
  4. Project & Infrastructure Context
  5. Activity Timeline Analysis

What it can do on your machine

Read from SKILL.md and the folder at commit 3eeca7d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • curl
    • jq

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use curl, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • PAPERCLIP_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Setup Routines loads about 3.1k tokens when it runs. Until then it costs about 98 tokens; SKILL.md has 917 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~98
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Yesterday-AI/paperclip-plugin-company-wizard at commit 3eeca7d, republished under its MIT licence (© Yesterday-AI). 917 words, ~3,138 tokens.

Download SKILL.mdSave it as .claude/skills/setup-routines/SKILL.md (or your agent's skills folder).
name
setup-routines
description
Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers. Replaces expensive always-on heartbeats with targeted, data-driven scheduled runs. Use when setting up routines for a new or existing company, or when optimizing token spend on agent heartbeats.

Setup Routines — Data-Driven Routine Provisioning

This skill analyzes a Paperclip company's actual operational data to design routines that match real needs — not generic templates. The goal: replace expensive always-on heartbeats with targeted routines that fire only when needed.

Heartbeats cost tokens. Routines save money.

Analysis Framework

Before creating a single routine, run the full diagnostic. Each step feeds signal into the routine design.

Phase 1: Company Health Snapshot

Pull the dashboard for a quick pulse check.

bash
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/dashboard" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

Extract:

  • Agent error count — agents in error state need a recovery routine
  • Open vs done ratio — high open count with low velocity = bottleneck
  • Blocked count — chronic blockers need an escalation routine
  • Budget utilization — high utilization = routines must be lean
  • Pending approvals — stalled approvals need a nudge routine
Phase 2: Issue Archaeology

Query completed and open issues to find recurring patterns.

bash
# Recent completed issues — look for repeat categories
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/issues?status=done&limit=100" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

# Open issues — find unassigned or stalled work
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/issues?status=todo,in_progress,blocked&limit=50" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

Pattern mining — look for these signals in issue titles and descriptions:

SignalWhat to look forRoutine type
Repeated bug categoryMultiple issues with same root cause (e.g., "fix lint", "CI broken", "runtime error")Preventive check — catch before it recurs
Unassigned high-prioritytodo issues with high/critical priority and no assigneeTriage routine for PM/CEO
Stalled in-progressin_progress issues with no recent comments/activityStall detector for CEO
Deploy-related issuesIssues mentioning deploy, Railway, Vercel, CI/CDPost-deploy verification with webhook trigger
API integration issuesIssues about external API failures, rate limits, authAPI health check routine
Error/crash issuesRuntime errors, hydration, crashes, 500sRuntime health patrol
Security issuesAuth bugs, secrets leaked, CORS, CSPSecurity audit periodic routine
Performance issuesLighthouse, Core Web Vitals, bundle sizePerformance regression check

Frequency analysis — count issues per category:

python
# Mental model for categorization (do this analysis in your head):
# Group done issues by theme:
#   CI/build failures: N issues → if N >= 3, needs a routine
#   Runtime crashes: N issues → if N >= 3, needs a routine
#   API integration: N issues → if N >= 2, needs a routine
#   Deploy issues: N issues → if N >= 2, needs a routine
#   Unassigned backlog: N items → if N >= 3 high-pri, needs triage routine
Phase 3: Agent Diagnostics
bash
# List agents with status
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/agents" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

Check each agent for:

  • Error state — needs recovery routine (critical priority)
  • Idle with open assignments — might be stuck, needs nudge
  • Budget near limit — routines for this agent should be conservative
  • Role-specific needs — CEO needs oversight routines, Engineer needs technical checks
Phase 4: Project & Infrastructure Context
bash
# Project details including workspace/repo
curl -s "$PAPERCLIP_API_URL/api/projects/{projectId}" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

Check for:

  • GitHub repo → can wire webhook triggers for push/PR events
  • Railway/Vercel deployment → can wire deploy webhook triggers
  • External API dependencies (Suno, Stripe, etc.) → need health check routines
  • Database → migration safety checks post-deploy
Phase 5: Activity Timeline Analysis
bash
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/activity?limit=50" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

Look for:

  • Activity gaps — long periods with no activity = agents might be stuck
  • Burst patterns — many issues created/closed at once = reactive mode (routines should prevent this)
  • Error clusters — multiple failures in a short window = systemic issue

Routine Design Rules

Priority Assignment
Routine concernPriorityRationale
Agent error recoverycriticalDead agents = zero productivity
CI/build healthhighBroken builds block all deploys
Runtime error patrolhighUser-facing failures
Unassigned high-pri triagehighBlocking features rot in backlog
API health checkmediumExternal dependency, catch early
Deploy verificationmediumPost-deploy safety net
Stall detectionmediumPrevents silent work stoppage
Performance/security auditlowImportant but not urgent
Backlog groominglowHousekeeping
Schedule Design
Routine typeRecommended scheduleWhy
Critical recovery0 8,12,17 * * 1-5 (3x/day)Fast recovery from errors
Build/CI guardWebhook on push + 0 10,16 * * 1-5 fallbackCatch failures at source
Runtime patrol0 */3 * * * (every 3h)Catch crashes between deploys
Triage0 9,14 * * 1-5 (2x/day)Morning + afternoon assignment windows
Deploy verifyWebhook on deploy + 0 11 * * 1-5 fallbackVerify each deploy + daily check
API health0 9 * * 1-5 (daily)Morning sanity check
Stall detection0 10 * * 1,3,5 (3x/week)Catch multi-day stalls
Audit (perf/security)0 10 * * 1 (weekly)Low-urgency, high-value
Show full SKILL.md (364 more words)Show less
Concurrency Policy Selection
Routine naturePolicyRationale
Health checks, patrolsskip_if_activeIdempotent — if already checking, new trigger adds nothing
Webhook-driven (each payload matters)always_enqueueEach push/deploy is a distinct event to verify
Triage, groomingcoalesce_if_activeMerge overlapping triage windows
Trigger Layering

Best practice: webhook + cron fallback for event-driven routines.

  • Webhook fires immediately on the event (push, deploy, error alert)
  • Cron fires daily/periodically as a safety net if webhook misses
  • This gives you both real-time response AND guaranteed coverage

Provisioning Procedure

After analysis, create routines in this order:

  1. Critical first — agent recovery, CI health
  2. High priority — runtime patrol, triage
  3. Medium — API checks, deploy verification
  4. Low — audits, grooming

For each routine:

bash
# Step 1: Create the routine
ROUTINE=$(curl -s -X POST "$PAPERCLIP_API_URL/api/companies/{companyId}/routines" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "...",
    "description": "... include specific issue references that motivated this routine ...",
    "assigneeAgentId": "...",
    "projectId": "...",
    "priority": "...",
    "status": "active",
    "concurrencyPolicy": "skip_if_active",
    "catchUpPolicy": "skip_missed"
  }')
ROUTINE_ID=$(echo "$ROUTINE" | jq -r '.id')

# Step 2: Add triggers
# Cron trigger
curl -s -X POST "$PAPERCLIP_API_URL/api/routines/$ROUTINE_ID/triggers" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"kind": "schedule", "cronExpression": "...", "timezone": "Europe/Amsterdam"}'

# Webhook trigger (if event-driven)
curl -s -X POST "$PAPERCLIP_API_URL/api/routines/$ROUTINE_ID/triggers" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"kind": "webhook", "signingMode": "bearer"}'

# Step 3: Test with manual run
curl -s -X POST "$PAPERCLIP_API_URL/api/routines/$ROUTINE_ID/run" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"source": "manual"}'

Routine Description Best Practices

Always include in the description:

  1. What the routine checks/does
  2. Why it exists — reference specific past issues by identifier (e.g., "Recurring: SUNAA-141, SUNAA-142, SUNAA-143 — lint errors breaking CI pipeline")
  3. What success looks like — the agent knows when the check passes
  4. What failure triggers — what should the agent do if the check fails

This context is injected into the agent's heartbeat when the routine fires, so a well-written description = fewer wasted tokens figuring out what to do.

Verification Checklist

After provisioning all routines:

bash
# List all active routines with triggers
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/routines" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

# For each routine, verify triggers exist
curl -s "$PAPERCLIP_API_URL/api/routines/{routineId}" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

# Fire a manual test run on the most critical routine
curl -s -X POST "$PAPERCLIP_API_URL/api/routines/{routineId}/run" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"source": "manual"}'

# Verify the run created an issue
curl -s "$PAPERCLIP_API_URL/api/routines/{routineId}/runs?limit=1" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY"

Output Summary Template

After completing setup, report:

## Routines Provisioned for {Company}

### Analysis Summary
- Issues analyzed: {N done} + {N open}
- Recurring patterns found: {list}
- Agents in error: {list}
- Unassigned high-priority: {count}

### Routines Created
| # | Title | Agent | Priority | Triggers | Rationale |
|---|-------|-------|----------|----------|-----------|
| 1 | ...   | ...   | ...      | ...      | Based on {issue pattern} |

### Webhook URLs (wire into external services)
- CI guard: POST {url} (GitHub push events)
- Deploy verify: POST {url} (Railway deploy events)

### Token Savings Estimate
- Previous: ~{N} heartbeats/day at ~{cost} tokens each
- Now: ~{N} targeted routine runs/day
- Estimated reduction: {X}%

Ongoing Maintenance

Routines aren't set-and-forget. Review monthly:

  1. Check run history — routines that never find issues can be reduced in frequency
  2. Check for new patterns — new recurring issue categories may need new routines
  3. Adjust schedules — align with team's actual working hours and deploy cadence
  4. Archive stale routines — if the underlying problem was permanently fixed
bash
# Quick health check on all routines
curl -s "$PAPERCLIP_API_URL/api/companies/{companyId}/routines" \
  -H "Authorization: Bearer $PAPERCLIP_API_KEY" | jq '.[] | select(.status=="active") | {title, lastTriggeredAt, lastEnqueuedAt}'

API Quick Reference

ActionMethodEndpoint
List routinesGET/api/companies/:companyId/routines
Create routinePOST/api/companies/:companyId/routines
Update routinePATCH/api/routines/:routineId
Add triggerPOST/api/routines/:routineId/triggers
Update triggerPATCH/api/routine-triggers/:triggerId
Delete triggerDELETE/api/routine-triggers/:triggerId
Manual runPOST/api/routines/:routineId/run
Run historyGET/api/routines/:routineId/runs?limit=50
Fire webhookPOST/api/routine-triggers/public/:publicId/fire
Rotate secretPOST/api/routine-triggers/:triggerId/rotate-secret

Auth Note (Local Docker)

If calling from outside the container (host machine), you need a board API key. Generate one via the Paperclip UI or by inserting a hashed key into the board_api_keys table. Agent API keys (PAPERCLIP_API_KEY) work from inside heartbeat runs but agents can only create routines assigned to themselves.

© Yesterday-AI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/setup-routines of Yesterday-AI/paperclip-plugin-company-wizard.

Open the folder on GitHubat commit 3eeca7d

Compare with similar skills

Setup Routines next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Setup Routines compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Setup Routines this skillYesterday-AI/paperclip-plugin-company-wizard186—~3.1kAutomated safety check: PassMIT
Workspace APIfriday-platform/friday-studio104—~9.3kAutomated safety check: NotesCustom licence
Convex RuntimeIgorWarzocha/Opencode-Workflows122—~1.1kAutomated safety check: PassNone
Nextclaw Self ManagePeiiii/nextclaw260—~3.5kAutomated safety check: PassMIT
Neon Functionsneondatabase/agent-skills100—~12kAutomated safety check: NotesApache-2.0
Function Devbutterbase-ai/butterbase-skills534—~2.8kAutomated safety check: PassMIT

Similar skills

  • Workspace API

    friday-platform/friday-studio

    Create, list, update, delete, and clean up workspaces via the daemon HTTP API at $FRIDAYDURL.

    104 GitHub stars~9.3k tokensUpdated 1 mo ago
    Backend & APIsAuto-check: notes

  • Convex Runtime

    IgorWarzocha/Opencode-Workflows

    Implement Convex runtime features: HTTP actions, file storage, search (full text + vector), scheduling (crons + scheduled functions), and RAG patterns.

    122 GitHub stars~1.1k tokensUpdated 8 mo ago
    Backend & APIsAuto-check passed

  • Nextclaw Self Manage

    Peiiii/nextclaw

    Self-manage NextClaw runtime via CLI guide. An agent skill from Peiiii/nextclaw.

    260 GitHub stars~3.5k tokensUpdated yesterday
    Backend & APIsAuto-check passed

  • Neon Functions

    neondatabase/agent-skills

    Official

    Long-running, serverless Node.js HTTP functions deployed onto your Neon branch, with DATABASEURL injected automatically and compute that runs next to your data.

    100 GitHub stars~12k tokensUpdated yesterday
    Backend & APIsAuto-check: notes

  • Function Dev

    butterbase-ai/butterbase-skills

    A skill your agent uses when developing, deploying, or debugging Butterbase serverless functions, or when the user needs to add backend logic like webhooks, scheduled jobs, or custom API endpoints

    534 GitHub stars~2.8k tokensUpdated 5 days ago
    Backend & APIsAuto-check passed

  • Upstash Qstash

    davila7/claude-code-templates

    Upstash QStash expert for serverless message queues, scheduled jobs, and reliable HTTP-based task delivery without managing infrastructure.

    33k GitHub starsUsed in 5 repos~597 tokens
    Backend & APIsAuto-check passed

More from Yesterday-AI/paperclip-plugin-company-wizard

  • Paperclip AI

    Yesterday-AI/paperclip-plugin-company-wizard

    Manage Paperclip AI companies, agents, issues, projects, goals, routines, costs, and secrets via REST API.

    186 GitHub stars~2.5k tokensUpdated 5 mo ago
    Auto-check passed

  • Release

    Yesterday-AI/paperclip-plugin-company-wizard

    Prepare a new release by updating CHANGELOG.md, verifying documentation (README.md, CLAUDE.md, AGENTS.md, ROADMAP.md, docs/), bumping patch version in package.json, building, and suggesting publish…

    186 GitHub stars~1.6k tokensUpdated 5 mo ago
    Auto-check passed

  • Routines

    Yesterday-AI/paperclip-plugin-company-wizard

    Set up and manage Paperclip Routines — recurring scheduled tasks that replace expensive always-on heartbeats.

    186 GitHub stars~2.1k tokensUpdated 5 mo ago
    Auto-check passed

Categories

Questions about Setup Routines

What does Setup Routines do?

Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers. Setup Routines is an agent skill from Yesterday-AI/paperclip-plugin-company-wizard. Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers.

When should I use Setup Routines?

Setup Routines fits situations like: setting up routines for a new; existing company; optimizing token spend on agent heartbeats.

How do I install Setup Routines in Claude Code?

Run `npx skills add Yesterday-AI/paperclip-plugin-company-wizard --skill setup-routines -a claude-code`. Or copy the skill folder (.claude/skills/setup-routines in Yesterday-AI/paperclip-plugin-company-wizard) into .claude/skills/setup-routines in your project. Claude Code loads it when a task matches its description.

How do I install Setup Routines in Codex?

Run `npx skills add Yesterday-AI/paperclip-plugin-company-wizard --skill setup-routines -a codex`. Or copy the skill folder (.claude/skills/setup-routines in Yesterday-AI/paperclip-plugin-company-wizard) into .agents/skills/setup-routines in your project. Codex loads it when a task matches its description.

Can I use Setup Routines in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Yesterday-AI/paperclip-plugin-company-wizard --skill setup-routines -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/setup-routines, .gemini/skills/setup-routines, .github/skills/setup-routines and .opencode/skills/setup-routines in your project.

What does Setup Routines need to run?

Going by SKILL.md and its folder, Setup Routines needs the command-line tools its instructions call (curl and jq) and credentials named PAPERCLIP_API_KEY. Our summary lists: Python 3; A credential in PAPERCLIP_API_KEY.

Does Setup Routines access the network?

SKILL.md contains no URLs. Its commands use curl, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Setup Routines safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Setup Routines use?

Setup Routines is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Setup Routines use?

About 3.1k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Setup Routines?

Skills that share tags, products or a category with Setup Routines: Workspace API (friday-platform/friday-studio, 104 stars), Convex Runtime (IgorWarzocha/Opencode-Workflows, 122 stars), Nextclaw Self Manage (Peiiii/nextclaw, 260 stars) and Neon Functions (neondatabase/agent-skills, 100 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Setup Routines?

Yesterday-AI (a GitHub organization) maintains it in Yesterday-AI/paperclip-plugin-company-wizard, which has 186 GitHub stars. The repository holds 4 skills in this directory. The repository was last updated on April 22, 2026.

Source: Yesterday-AI/paperclip-plugin-company-wizard on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.