Linear Autopilot

Automate Linear task processing with Discord notifications and git sync. Use when setting up a kanban-to-agent workflow where Linear tasks trigger Clawdbot a...

Security Scan

The skill's purpose (Linear → Discord → git automation) is plausible, but the runtime instructions and included script require credentials and binaries that the registry metadata does not declare and give the agent/skill broader scope than advertised.

Purpose & Capability

The skill claims to automate Linear tasks with Discord notifications and git sync, which matches the provided scripts and guides. However, the registry metadata declares no required environment variables or binaries, while the SKILL.md and scripts require a LINEAR_API_KEY, and expect tools such as curl, jq and git. This mismatch is incoherent: a Linear integration legitimately needs an API key and network tools, so those should be declared.

Instruction Scope

The SKILL.md instructs creating ~/.clawdbot/linear.env and ~/.clawdbot/linear-config.json and to place API keys and Discord/Clawdbot tokens into automation services. It also tells the agent to 'spawn sub-agent if complex' and to run git commit/push. Those steps go beyond merely translating events and include file writes, network calls, and autonomous sub-agent spawning — all of which widen the operational scope and require explicit declaration and user attention.

Install Mechanism

There is no install spec (instruction-only), which is lower risk. The repo includes a shell script that will be run by the user. No remote downloads or extraction are present. Still, the script depends on curl, jq and git being available and will read/write files in the user's home directory; these runtime expectations should be documented in metadata.

Credentials

The registry lists no required env vars, but SKILL.md and scripts require LINEAR_API_KEY and the guides instruct using Clawdbot/Discord bot tokens in automation platforms. Those credentials are necessary for the functionality, so omitting them from declared requirements is an inconsistency. The skill asks users to store secrets in a plaintext file (~/.clawdbot/linear.env) without recommending permissions or limited-scope keys.

Persistence & Privilege

The skill is not always: true and does not request elevated platform privileges. It writes/reads its own config under ~/.clawdbot and references clawdbot.json (Clawdbot config), which is reasonable for this integration, but users should be aware the skill will create files in their home directory.

What to consider before installing

This skill appears to implement the advertised Linear → Discord → git workflow, but there are important mismatches and privacy considerations you should address before installing: - Metadata vs instructions: The registry declares no required env vars or binaries, but SKILL.md and scripts require a LINEAR_API_KEY and expect curl, jq, and git. Treat the script as requiring these tools and the API key even though the registry omits them. - Secrets handling: The instructions ask you to store your Linear API key in ~/.clawdbot/linear.env and to use Discord/Clawdbot tokens in automation services. Use a limited-scope Linear key if available, set file permissions (chmod 600 ~/.clawdbot/linear.env), and avoid pasting credentials into third-party paste sites. Consider creating service-specific or short-lived tokens. - Review the script before running: scripts/linear-api.sh performs GraphQL calls using your API key, parses JSON with jq, and can run git commit/push as part of the workflow. Inspect it locally and run it manually in a controlled environment first. Ensure you have jq/curl/git installed and understand how git push will authenticate (SSH key or credential helper). - External services and bot tokens: The guides recommend Make.com, Pipedream, or Zapier and instruct you to attach your Clawdbot Discord bot token to workflows. Grant the Discord bot the minimum permissions it needs and prefer webhooks where possible to avoid exposing bot tokens widely. - Autonomous scope: The SKILL.md mentions spawning sub-agents and automatically processing tasks. If you will allow autonomous agent invocation, be explicit about limits and where outputs are written (research/, content/, etc.). If you prefer manual control, run the workflow in a test environment first. If you want to proceed: (1) inspect the scripts and SKILL.md thoroughly, (2) create limited-scope API tokens, (3) set strict file permissions for stored secrets, (4) test in an isolated repo and Discord server, and (5) ensure your automation platform (Make/Pipedream/Zapier) does not expose tokens in logs you can't control.

🔒 Security Note: This skill mentions API keys, tokens, and webhook URLs because it teaches you how to set up integrations with Linear, Discord, and automation services (Make.com, Pipedream, Zapier). These are necessary for the tutorial — the skill does NOT collect or transmit your credentials. All setup happens on your local machine and the services you configure.

Automated pipeline: Linear → Webhook Service → Discord → Clawdbot → Git

Tasks created in Linear automatically trigger Clawdbot processing with real-time notifications and git sync for Obsidian/local access.

Free Tier Limitations

Before setup, be aware of free plan limits:

Service	Free Tier Limits	Recommendation
Linear	250 issues, unlimited members	Sufficient for most personal/small team use
Make.com	1,000 ops/month, 2 scenarios, 15-min interval	✅ Best free option — generous limits
Pipedream	~100 credits (unclear reset), instant triggers	Good if you need real-time, burns credits fast
Zapier	100 tasks/month, 5 zaps, 15-min polling, no webhooks	⚠️ Paid plan required for this workflow

Important notes:

• Make.com offers 1,000 ops/month free — our recommendation for free tier users
• Pipedream has instant webhooks but limited free credits that deplete quickly
• Zapier free plan does NOT support webhooks. You need a paid Zapier plan (Starter+)
• For budget-conscious users: use Make.com

Setup

1. Configure Linear API

Run setup to store your Linear API key:

mkdir -p ~/.clawdbot
echo "LINEAR_API_KEY=lin_api_xxxxx" > ~/.clawdbot/linear.env

Get your API key from: Linear → Settings → API → Personal API keys

2. Get Linear IDs

Find your team and state IDs:

./scripts/linear-api.sh teams    # Get team ID
./scripts/linear-api.sh states   # Get state IDs (Todo, In Progress, Done)

Update ~/.clawdbot/linear-config.json:

{
  "teamId": "your-team-id",
  "states": {
    "todo": "state-id-for-todo",
    "inProgress": "state-id-for-in-progress",
    "done": "state-id-for-done"
  },
  "discord": {
    "notifyUserId": "your-discord-user-id",
    "taskChannelId": "your-linear-tasks-channel-id"
  },
  "git": {
    "autoPush": true,
    "commitPrefix": "task:"
  }
}

3. Set Up Webhook Service

Choose your preferred automation platform:

Option A: Make.com (Recommended for free tier)

• 1,000 operations/month free
• 15-minute minimum interval on free tier
• See references/make-setup.md for step-by-step guide

Quick setup:

1. Create scenario at make.com
2. Add Linear "Watch Issues" trigger
3. Add filter: state.name = "Todo"
4. Add Discord webhook action
5. Activate scenario

Option B: Pipedream (If you need instant triggers)

• Instant webhook triggers
• Limited free credits (deplete fast)
• See references/pipedream-setup.md for step-by-step guide

Quick setup:

1. Create workflow at pipedream.com with HTTP webhook trigger
2. Add Linear webhook pointing to your Pipedream URL
3. Add Discord "Send Message" step with Clawdbot bot token
4. Message template:

   <@BOT_ID>
   📋 New task: {{steps.trigger.event.data.title}}
     Status: {{steps.trigger.event.data.state.name}}
     ID: {{steps.trigger.event.data.identifier}}
   

Option B: Zapier (If you have a paid account)

• 100 tasks/month on free (very limited)
• Native Linear + Discord integrations
• See references/zapier-setup.md for step-by-step guide

Quick setup:

1. Create Zap: Linear (New Issue) → Discord (Send Channel Message)
2. Use webhook or bot integration for Discord
3. Map Linear fields to message template

4. Configure Discord Channel

Ensure Clawdbot listens to your task channel. In clawdbot.json:

{
  "channels": {
    "discord": {
      "guilds": {
        "YOUR_GUILD_ID": {
          "channels": {
            "YOUR_TASK_CHANNEL_ID": {
              "allow": true,
              "requireMention": false
            }
          }
        }
      }
    }
  }
}

Task Processing Workflow

When a task arrives in the Discord channel:

1. Acknowledge

• Reply in channel confirming receipt

2. Notify User via DM

Use message tool:
- action: send
- target: [user ID from config]
- message: "📋 New task: [ID] - [title]. Starting now..."

3. Process Task

• Update Linear status → "In Progress" via ./scripts/linear-api.sh start [task-id]
• Execute the task (spawn sub-agent if complex)
• Save outputs to appropriate location (research/, content/, etc.)

4. Complete

• Update Linear status → "Done" via ./scripts/linear-api.sh done [task-id]
• Add comment with results via ./scripts/linear-api.sh comment [task-id] "[summary]"
• Send completion DM to user

5. Git Sync (if enabled)

git add [output files]
git commit -m "task: [ID] - [title]"
git push

Script Reference

scripts/linear-api.sh commands:

Command	Description
teams	List teams and IDs
states	List workflow states
get [id]	Get task details
pending	List pending tasks
start [id]	Mark as In Progress
done [id]	Mark as Done
comment [id] "text"	Add comment to task

Example Task Types

This workflow handles any task type:

• Research: Spawn sub-agent, save to research/[topic].md
• Content creation: Generate drafts, save to content/
• Code tasks: Write/modify code, commit changes
• Data processing: Run scripts, output results
• Custom: Define your own output patterns

Troubleshooting

Tasks not triggering?

• Check Pipedream workflow is enabled
• Verify Discord channel is in Clawdbot config
• Ensure allowBots: true if using webhook

Linear API errors?

• Verify API key in ~/.clawdbot/linear.env
• Check team/state IDs are correct

Git push failing?

• Ensure git remote is configured
• Check SSH key or credentials