# OpenClaw for Developers: The Ultimate Productivity Setup

Canonical: https://clawdocx.com/docs/developer-productivity
Author: Sam Okafor
Difficulty: INTERMEDIATE
Published: 2026-02-24
Updated: 2026-09-19

> A developer productivity guide for OpenClaw: set up automated PR reviews, CI/CD monitoring, standup generation, sprint tracking, and deployment workflows.

## The Developer's Agent Stack

Software engineering involves a constant stream of context switches: reviewing PRs, triaging issues, monitoring deployments, updating tickets, and communicating progress to your team. Each switch carries a cognitive cost. OpenClaw can absorb many of these operational tasks so you can focus on writing code.

This guide walks through the essential skills and configurations that turn OpenClaw into a developer's operational backbone. By the end, you will have:

- Automated PR reviews on every push
- CI/CD pipeline monitoring with instant failure alerts
- Daily standup generation from git and issue tracker history
- Sprint management through natural language
- A deployment workflow with safety checks
- Cron jobs that deliver a morning PR digest and end-of-day summary

> **Note**
>
> This guide is designed for individual developers and small teams. For large engineering organizations, the same skills apply but you will want to review permission scoping and cost management more carefully. See the [Cost Optimization Guide](/docs/cost-optimization) for team-scale cost planning.

---

## Required Skills

> **Warning**
>
> The six skill names in this guide (`github-bridge`, `linear-sync`, `cicd-monitor`, `nextjs-docs`, `flaw0-scanner`, `workflow-builder`) are placeholders. Querying ClawHub's search API for each one exactly, at `/api/v1/search?q=<slug>&mode=exact`, returned an empty result list for all six on September 19, 2026, and the fields inside their `config` blocks are equally illustrative. Treat both as stand-ins for whichever skills you actually install, and check the real names, refs and option names on the skill's ClawHub listing before copying any command or config below.

Install the developer skill stack. Every documented `skills install` example passes a single ref, in one of the documented forms: `@owner/<slug>`, `skills-sh:<owner>/<repo>/<slug>`, `git:owner/repo`, or a local path. The publisher scope in front of the slug comes from the skill's ClawHub listing, so replace `<publisher>` with the one shown there.

```bash
openclaw skills install @<publisher>/github-bridge
openclaw skills install @<publisher>/linear-sync
openclaw skills install @<publisher>/cicd-monitor
openclaw skills install @<publisher>/nextjs-docs
```

Optional but recommended:

```bash
openclaw skills install @<publisher>/flaw0-scanner
openclaw skills install @<publisher>/workflow-builder
```

### Skill Purpose Map

| Skill | What It Does |
|-------|-------------|
| `github-bridge` | PR reviews, issue management, code search, release notes |
| `linear-sync` | Sprint tracking, standup generation, issue prioritization |
| `cicd-monitor` | Pipeline monitoring, failure alerts, deployment tracking |
| `nextjs-docs` | Framework-specific help (swap for your framework of choice) |
| `flaw0-scanner` | Security scanning for your codebase |
| `workflow-builder` | Chain skills together for complex workflows |

---

## GitHub Skill Deep Dive

The GitHub Bridge skill is the centerpiece of the developer setup. It integrates deeply with GitHub's API to automate the most time-consuming parts of working with repositories.

### Automated PR Reviews

Per-skill settings have a documented shape. They live under `skills.entries.<key>`, where "Keys under `entries` match the skill `name` by default", `apiKey` is the "Convenience field for skills that declare `metadata.openclaw.primaryEnv`" and takes "a plaintext string or a SecretRef", and `config` is the "Optional bag for custom per-skill configuration fields". Everything inside `config` belongs to the skill you installed rather than to OpenClaw's schema, so check those field names against that skill's own documentation. The surrounding keys are checked: "OpenClaw only accepts configurations that fully match the schema."

Configure the agent to automatically review PRs when code is pushed:

```json5
{
  skills: {
    entries: {
      "github-bridge": {
        enabled: true,
        apiKey: { source: "env", provider: "default", id: "GITHUB_TOKEN" },
        config: {
          auto_review: {
            enabled: true,
            trigger: "on_push", // skill-owned field, not an OpenClaw config key
            repos: ["your-org/main-repo", "your-org/api-service"],
            review_model: "claude-sonnet-4-6-20260217",
            review_standards: {
              code_quality: {
                enabled: true,
                check_naming: true,
                check_complexity: true,
                max_function_length: 50,
                check_duplication: true,
              },
              security: {
                enabled: true,
                check_sql_injection: true,
                check_xss: true,
                check_secrets: true,
                check_dependencies: true,
              },
              performance: {
                enabled: true,
                check_n_plus_one: true,
                check_memory_leaks: true,
                check_async_patterns: true,
              },
              testing: {
                enabled: true,
                require_tests: true,
                min_coverage_suggestion: true,
              },
            },
            review_format: {
              summary: true,
              inline_comments: true,
              severity_labels: true,
              approval_recommendation: true,
            },
            ignore_patterns: ["*.lock", "*.generated.*", "package-lock.json", "yarn.lock"],
          },
        },
      },
    },
  },
}
```

### What the Review Covers

When a PR is opened or pushed to, the agent:

1. **Reads the full diff** — Every changed file, every line
2. **Analyzes code quality** — Naming conventions, function complexity, code duplication
3. **Checks for security issues** — Injection vulnerabilities, exposed secrets, unsafe patterns
4. **Evaluates performance** — N+1 queries, memory leaks, missing async/await
5. **Verifies testing** — Are there tests for new functionality? Do test names describe behavior?
6. **Posts a review summary** — Overall assessment with inline comments on specific lines
7. **Sends you a notification** — Via your configured messaging channel

Example review output posted to the PR:

```markdown
## Agent Review Summary

**Overall Assessment:** Mostly good, 2 issues to address before merge.

### Issues Found

#### 🔴 Security (Critical)
- `src/api/users.ts:42` — SQL query uses string interpolation instead of
  parameterized query. This is a SQL injection vulnerability.

#### 🟡 Performance (Warning)
- `src/services/orders.ts:78-92` — This loop makes a database query on
  each iteration. Consider batch-fetching orders to avoid N+1 query.

#### 🟢 Code Quality (Suggestion)
- `src/utils/helpers.ts:15` — Function `processData` is 67 lines long.
  Consider breaking it into smaller focused functions.

### What Looks Good
- Clean separation of concerns in the new middleware
- Good error handling with typed error responses
- Tests cover the happy path and two edge cases

**Recommendation:** Request changes (address the SQL injection issue)
```

> **Tip**
>
> Set `review_model` to Sonnet 4.6 for routine PR reviews. It catches most issues at a fraction of the cost of Opus. Reserve Opus for reviewing critical PRs (security-sensitive code, architecture changes) by adding a label-based override: if a PR has the label "needs-thorough-review", use Opus.

### Issue Management

Beyond reviews, the GitHub skill manages issues:

```json5
{
  skills: {
    entries: {
      "github-bridge": {
        enabled: true,
        config: {
          issue_management: {
            auto_label: true,
            label_model: "claude-haiku-4-20260210",
            auto_assign: {
              enabled: true,
              rules: {
                frontend: "frontend-team-lead",
                backend: "backend-team-lead",
                security: "security-team-lead",
              },
            },
            triage_new_issues: true,
            stale_issue_check: {
              enabled: true,
              days_until_stale: 30,
              comment_on_stale: true,
            },
          },
        },
      },
    },
  },
}
```

**Capabilities:**
- Auto-label new issues based on content analysis (bug, feature, docs, etc.)
- Auto-assign issues to the right person based on content keywords
- Triage new issues: add priority labels and initial comments
- Detect and flag stale issues that need attention
- Search code across all repos to answer "where is X implemented?"

### Code Search Across Repos

Ask your agent to find code patterns across your organization:

```
You: "Find all places where we use the deprecated `fetchUser` function"
Agent: "Found 14 occurrences across 3 repos:
  - org/main-app: 8 occurrences (src/services/auth.ts, src/api/users.ts, ...)
  - org/api-service: 4 occurrences (src/handlers/user.ts, ...)
  - org/admin-panel: 2 occurrences (src/lib/api.ts, ...)
  Shall I create a tracking issue for the migration?"
```

### Automated Release Notes

Generate release notes from PR descriptions and commit messages:

There is no `--schedule` flag. The documented creation form puts the schedule first and the prompt second:

```bash
openclaw cron add "0 17 * * 5" "Check if there are any new merged PRs since the last release tag. If there are more than 5, generate release notes organized by category (features, fixes, improvements) and post them as a draft GitHub release." --model anthropic/claude-sonnet-4-6
```

---

## Linear/Jira Integration

The Linear Sync skill connects your agent to your project management tool. Everything that follows uses Linear, but the concepts apply equally to Jira with the `jira-sync` skill.

### Sprint Planning Assistance

```json5
{
  skills: {
    entries: {
      "linear-sync": {
        enabled: true,
        apiKey: { source: "env", provider: "default", id: "LINEAR_API_KEY" },
        config: {
          team_id: "your-team-id",
          sprint_planning: {
            enabled: true,
            suggest_priorities: true,
            estimate_complexity: true,
            balance_workload: true,
            carry_over_incomplete: true,
          },
        },
      },
    },
  },
}
```

Ask your agent for sprint planning help:

```
You: "Help me plan next sprint. What didn't get done this sprint,
     and what's the highest priority in the backlog?"

Agent: "Current sprint ends Friday. Here's the status:
  Completed: 14 issues (42 points)
  In Progress: 3 issues (8 points) — likely to finish
  Not Started: 2 issues (5 points) — should carry over

  For next sprint, here are the top priorities from the backlog:
  1. [HIGH] Payment processing refactor (8 pts) — blocked 3 other issues
  2. [HIGH] Fix authentication timeout bug (3 pts) — 12 customer reports
  3. [MED] Add pagination to user list API (5 pts) — performance bottleneck
  4. [MED] Update onboarding flow (5 pts) — design approved last week
  5. [LOW] Migrate to new logging library (3 pts) — tech debt

  Based on the team's velocity of ~45 points, I'd suggest taking all 5
  plus the 2 carry-overs for a total of 29 points, leaving room for
  unplanned work."
```

### Automated Standup Reports

Generate standups automatically from git commits and Linear status changes:

```json5
{
  skills: {
    entries: {
      "linear-sync": {
        enabled: true,
        config: {
          auto_standup: {
            enabled: true,
            schedule: "0 9 * * 1-5",
            channel: "telegram",
            model: "claude-sonnet-4-6-20260217",
            data_sources: {
              git_commits: {
                enabled: true,
                repos: ["org/main-repo", "org/api-service"],
                lookback_hours: 24,
              },
              linear_updates: {
                enabled: true,
                include_status_changes: true,
                include_comments: true,
              },
              pr_activity: {
                enabled: true,
                include_reviews: true,
                include_merges: true,
              },
            },
            format: {
              sections: ["yesterday", "today", "blockers"],
              tone: "concise and factual",
              max_items_per_section: 5,
            },
          },
        },
      },
    },
  },
}
```

Example standup output:

```markdown
## Daily Standup — Tuesday, Feb 24

### Yesterday
- Merged PR #342: Add rate limiting to public API endpoints
- Reviewed and approved PR #339: Database migration for user preferences
- Moved LIN-456 (payment refactor) to In Review
- Fixed flaky test in CI (3 commits to test/integration/payments.test.ts)

### Today
- LIN-456: Payment refactor — address review comments, target merge
- LIN-461: Start authentication timeout investigation (12 customer reports)
- PR #339: Follow up on migration — verify staging deployment

### Blockers
- None currently. Waiting on design review for LIN-470 (onboarding flow)
  but it's not blocking this sprint's work.
```

> **Tip**
>
> Share standup output in a team Slack or Discord channel so the whole team benefits. Configure the cron to post to a `#standups` channel, and each team member's agent posts their own standup. This eliminates the daily standup meeting for async teams.

### Issue Prioritization

The agent can help prioritize your backlog based on multiple signals:

```
You: "Prioritize the backlog for the API team based on customer impact,
     technical debt, and blocking relationships."

Agent: "Here's the prioritized backlog:

  Priority 1 (Do First):
  - LIN-456: Payment processing refactor — blocks LIN-458, LIN-460, LIN-462
  - LIN-461: Auth timeout bug — 12 customer reports, revenue impact

  Priority 2 (Do Next):
  - LIN-470: Onboarding flow update — design approved, improves conversion
  - LIN-473: Pagination for user list — performance degradation at scale

  Priority 3 (Backlog):
  - LIN-480: Logging library migration — tech debt, no customer impact
  - LIN-482: Add dark mode to admin panel — nice to have

  Reasoning: I prioritized based on blocking relationships first (LIN-456
  unblocks 3 issues), then customer-reported bugs, then customer-facing
  improvements, then internal improvements."
```

---

## Code Review Automation with Agent Teams

One of OpenClaw's most powerful developer features is using agent teams for code review: one agent writes code, and another reviews it with different review standards.

### Setting Up a Review Agent

Create a second agent. There is no `agent_teams` key: per-agent overrides live under `agents.entries`, where "The `agents.entries` object key is the stable agent id" and `workspace`, `model` and `skills` are documented fields. An explicit skills list "replaces defaults instead of merging".

```json5
{
  agents: {
    entries: {
      "code-reviewer": {
        name: "Code Reviewer",
        workspace: "~/.openclaw/workspace-code-reviewer",
        model: "anthropic/claude-sonnet-4-6",
        skills: ["github-bridge", "flaw0-scanner"],
      },
    },
  },
}
```

The CLI writes the same entry for you:

```bash
openclaw agents add code-reviewer --workspace ~/.openclaw/workspace-code-reviewer
```

`agents.entries` has no `trigger` key, and no `review_strictness`, `focus_areas` or `tone` key. How strictly the agent reviews is written in its workspace files, not in config, and which work reaches it is decided by routing or delegation: `bindings` map a channel account to an agent, and `subagents.allowAgents` names the agents a coordinator may spawn.

Create the reviewer's personality in that workspace, at `~/.openclaw/workspace-code-reviewer/SOUL.md`:

```markdown
# Code Reviewer Agent

You are a senior software engineer conducting code reviews. Your reviews are:

- Thorough but not nitpicky. Focus on issues that matter.
- Security-first. Always check for vulnerabilities before anything else.
- Constructive. Every criticism comes with a suggested improvement.
- Contextual. Understand the PR's purpose before reviewing details.

## Review Checklist
1. Security: injection, authentication, authorization, data exposure
2. Performance: queries, loops, memory, caching
3. Correctness: edge cases, error handling, race conditions
4. Maintainability: naming, complexity, documentation
5. Testing: coverage, edge cases, test quality

## What to Skip
- Style nitpicks that a formatter should handle
- Personal preferences that don't affect quality
- Changes outside the PR's scope (file a separate issue instead)
```

### Configurable Review Standards

Define different review standards for different repositories or file types:

```json5
{
  skills: {
    entries: {
      "github-bridge": {
        enabled: true,
        config: {
          auto_review: {
            repo_overrides: {
              "org/main-repo": {
                review_model: "claude-opus-4-6-20260217",
                review_standards: ["security", "performance", "testing"],
                require_tests: true,
              },
              "org/docs-site": {
                review_model: "claude-haiku-4-20260210",
                review_standards: ["spelling", "links", "formatting"],
                require_tests: false,
              },
              "org/prototype": {
                review_model: "claude-haiku-4-20260210",
                review_standards: ["security"],
                require_tests: false,
              },
            },
          },
        },
      },
    },
  },
}
```

This applies strict reviews with Opus to your main production repo, light reviews to documentation, and security-only reviews to prototype repos.

---

## NextJS 16 Docs Skill

The NextJS Docs skill bakes the complete Next.js 16 documentation into your agent's knowledge. Instead of searching the docs website, ask your agent directly.

### Common Use Cases

**Migration assistance:**
```
You: "I'm migrating from Next.js 14 to 16. What are the breaking changes
     I need to handle?"

Agent: [Detailed list of breaking changes with code migration examples]
```

**Pattern guidance:**
```
You: "What's the best way to handle authentication in Next.js 16 App Router
     with server components?"

Agent: [Explanation with code examples for middleware-based auth, server
       component checks, and client component patterns]
```

**Best practice checks:**
```
You: "Review my app/page.tsx for Next.js anti-patterns."

Agent: [Analysis of the file with specific recommendations]
```

### Configuration

```json5
{
  skills: {
    entries: {
      "nextjs-docs": {
        enabled: true,
        config: {
          version: "16",
          include_examples: true,
          migration_helpers: true,
          best_practice_checks: true,
          project_path: "/Users/you/projects/my-nextjs-app",
          watch_for_updates: true,
          update_channel: "stable",
        },
      },
    },
  },
}
```

> **Note**
>
> The NextJS Docs skill is one of many framework-specific skills on ClawHub. Similar skills exist for React (`react-docs`), Vue (`vue-docs`), Svelte (`svelte-docs`), Astro (`astro-docs`), and more. Install the one that matches your framework.

---

## CI/CD Monitoring

The CI/CD Monitor skill watches your pipelines and alerts you when things break.

### Configuration

```json5
{
  skills: {
    entries: {
      "cicd-monitor": {
        enabled: true,
        config: {
          providers: {
            github_actions: {
              token: "ghp_your_token",
              repos: ["org/main-repo", "org/api-service"],
              watched_workflows: ["ci.yml", "deploy.yml", "test.yml"],
            },
          },
          alerts: {
            on_failure: {
              enabled: true,
              channel: "telegram",
              include_logs: true,
              log_lines: 50,
              mention_author: true,
            },
            on_success_after_failure: {
              enabled: true,
              channel: "telegram",
              message: "Pipeline recovered",
            },
            on_long_running: {
              enabled: true,
              threshold_minutes: 30,
              channel: "telegram",
            },
          },
          auto_create_issue: {
            enabled: true,
            tracker: "linear",
            label: "ci-failure",
            assign_to_author: true,
          },
          daily_summary: {
            enabled: true,
            schedule: "0 17 * * 1-5",
            channel: "telegram",
          },
        },
      },
    },
  },
}
```

### Failure Alert Example

When a pipeline fails, you receive a message like:

````markdown
🔴 CI Failure: org/main-repo — ci.yml

**Branch:** feature/add-rate-limiting
**Author:** @yourname
**Commit:** abc1234 "Add rate limiting middleware"
**Failed Job:** integration-tests
**Duration:** 4m 32s

**Relevant Logs (last 30 lines):**
```
FAIL src/test/integration/rate-limit.test.ts
  ● Rate Limiting › should return 429 after 100 requests

    Expected: 429
    Received: 200

    at Object.<anonymous> (src/test/integration/rate-limit.test.ts:45:27)

Test Suites: 1 failed, 24 passed
Tests: 1 failed, 156 passed
```

**Auto-created Linear issue:** LIN-501
**Quick link:** [View workflow run](https://github.com/org/main-repo/actions/runs/123)
````

> **Tip**
>
> Enable `on_success_after_failure` to get a positive notification when a previously failing pipeline passes. This closes the feedback loop — you know when your fix worked without going back to check.

---

## Daily Standup Generation

Combine git history, Linear status, and PR activity into automated standups:

```bash
openclaw cron add "0 9 * * 1-5" "Generate my daily standup. Check git commits from the last 24 hours across all watched repos. Check Linear for status changes and comments. Check GitHub for PR activity (opened, reviewed, merged). Format as Yesterday/Today/Blockers." --model anthropic/claude-sonnet-4-6
```

### Standup Customization

Adjust the standup format in your SOUL.md:

```markdown
## Standup Format

When generating standups:
- Keep each item to one line. No lengthy descriptions.
- Link to PRs and issues when referencing them.
- For "Today" section, pull from Linear issues assigned to me that are
  In Progress or marked as next up.
- Only include blockers if they are genuine blockers. Do not fabricate
  blockers to fill the section. If there are no blockers, say "None."
- Total standup should be under 15 lines.
```

---

## Deployment Automation

Set up a staging-to-production deployment workflow with safety checks. As above, `github-bridge` and every field inside its `config` bag are illustrative: `config` is the "Optional bag for custom per-skill configuration fields", so those names belong to the skill rather than to OpenClaw's schema, and the real ones come from the skill's ClawHub listing.

```json5
{
  skills: {
    entries: {
      "github-bridge": {
        enabled: true,
        config: {
          deployment: {
            staging: {
              branch: "staging",
              auto_deploy: true,
              trigger: "merge_to_staging", // skill-owned field, not an OpenClaw config key
              checks: ["ci_pass", "no_critical_issues"],
            },
            production: {
              branch: "main",
              auto_deploy: false,
              require_approval: true,
              approval_channel: "telegram",
              checks: [
                "ci_pass",
                "staging_healthy_for_hours",
                "no_critical_issues",
                "no_active_incidents",
              ],
              staging_healthy_hours: 4,
              rollback_on_failure: true,
              notification_channel: "telegram",
            },
          },
        },
      },
    },
  },
}
```

### Deployment Workflow

### Step 1: Code merges to staging branch

When a PR is merged to the staging branch, the agent automatically triggers a staging deployment and monitors the CI pipeline.

### Step 2: Staging health check

The agent monitors the staging environment for the configured period (e.g., 4 hours). It checks application health endpoints, error rates, and performance metrics.

### Step 3: Production readiness check

After the staging health period, the agent runs pre-deployment checks: CI is passing, no critical issues in the tracker, no active incidents, staging has been healthy for the required period.

### Step 4: Approval request

The agent sends you a message: 'Staging has been healthy for 4 hours. All checks pass. Ready to deploy to production?' You reply 'approve' to proceed.

### Step 5: Production deployment

The agent merges staging to main (or triggers your deployment pipeline) and monitors the production deployment.

### Step 6: Post-deployment monitoring

For the next hour, the agent monitors error rates and performance. If anything degrades, it alerts you and can trigger an automatic rollback.

---

## Complete Developer openclaw.json

Here is a comprehensive configuration for a developer setup. Automation jobs are deliberately absent: they "live in the shared SQLite state database", not in this file, and the `cron` block is strict, with `cron.enabled`, `cron.skipMissedJobs`, `cron.triggers`, `cron.webhookToken`, `cron.webhookSsrfPolicy`, `cron.sessionRetention` and `cron.failureAlert` the only keys it accepts. Create the jobs with `openclaw cron add`, as the next section does.

```json5
{
  agents: {
    defaults: {
      model: { primary: "anthropic/claude-sonnet-4-6" },
      heartbeat: {
        every: "15m",
        activeHours: { start: "08:00", end: "22:00" },
        // model: "<provider>/<model>" runs the heartbeat on a cheaper route
      },
      userTimezone: "America/New_York",
    },
  },
  channels: {
    telegram: {
      enabled: true,
      botToken: "your-telegram-bot-token",
      dmPolicy: "allowlist",
      allowFrom: ["tg:123456789"],
    },
  },
  skills: {
    entries: {
      "github-bridge": {
        enabled: true,
        apiKey: { source: "env", provider: "default", id: "GITHUB_TOKEN" },
        config: {
          default_org: "your-org",
          auto_review: { enabled: true, on_push: true },
        },
      },
      "linear-sync": {
        enabled: true,
        apiKey: { source: "env", provider: "default", id: "LINEAR_API_KEY" },
        config: { team_id: "your-team-id" },
      },
      "cicd-monitor": {
        enabled: true,
        config: {
          providers: {
            github_actions: { repos: ["org/main-repo"] },
          },
          alert_on: ["failure"],
          alert_channel: "telegram",
        },
      },
      "nextjs-docs": {
        enabled: true,
        config: { version: "16", project_path: "/path/to/your/project" },
      },
    },
  },
  cron: {
    enabled: true,
  },
}
```

---

## Cron Jobs for Developers

Create the schedule with `openclaw cron add`, one job per command, schedule first. Give `--announce` an explicit `--to` target: the docs note that for `channel: "last"`, "the preview shows whether the route resolved from the main or current session, or will fail closed."

```bash
openclaw cron add "0 8 * * 1-5" "Morning PR digest: List all open PRs across watched repos. For each PR, show title, author, age, review status, and CI status. Highlight PRs that need my review." --name "Morning PR digest" --announce --channel telegram --to "-1001234567890"
openclaw cron add "0 9 * * 1-5" "Generate daily standup from git commits (last 24h), Linear status changes, and PR activity. Format as Yesterday/Today/Blockers." --name "Daily standup" --announce --channel telegram --to "-1001234567890"
openclaw cron add "0 18 * * 1-5" "End-of-day commit summary: List all commits I made today across all repos. Group by repo. Include total lines changed and PRs opened/merged." --name "End of day" --announce --channel telegram --to "-1001234567890"
openclaw cron add "0 */3 * * 1-5" "CI health check: Report on pipeline status across all watched repos. Only message me if there are failures or unusually long-running pipelines." --name "CI health" --announce --channel telegram --to "-1001234567890"
openclaw cron add "0 16 * * 5" "Friday sprint summary: Summarize the sprint progress. Issues completed, in progress, and not started. Velocity compared to target. Blockers and risks for next week." --name "Sprint summary" --announce --channel telegram --to "-1001234567890"
```

Use your own chat id in `--to`. Use `--tz <iana>` for a job's evaluation timezone, and `openclaw cron disable <job-id>` rather than an `enabled` field: a job's enabled state is changed with the `enable` and `disable` subcommands.

### Morning PR Digest (8:00 AM Weekdays)

Start your day knowing what needs your attention:

```
## Morning PR Digest — Tuesday, Feb 24

### Needs Your Review (2)
- **#345** Add rate limiting to API (by @alice, opened 2 days ago)
  CI: ✅ Passing | Size: +342/-28 | Labels: backend, security
- **#347** Fix user preferences migration (by @bob, opened yesterday)
  CI: ✅ Passing | Size: +56/-12 | Labels: database, bug

### Your Open PRs (1)
- **#342** Implement caching layer (opened 3 days ago)
  Reviews: 1 approved, 1 changes requested | CI: ✅ Passing
  → @carol requested changes on the cache invalidation logic

### Recently Merged (2)
- **#340** Update dependencies (merged yesterday by @alice)
- **#338** Add error tracking middleware (merged 2 days ago by you)
```

### End-of-Day Commit Summary (6:00 PM Weekdays)

Close your day with a record of what you accomplished:

```
## End of Day Summary — Tuesday, Feb 24

### Commits Today: 7

**org/main-repo** (5 commits, +245/-89)
- abc1234 Implement cache invalidation for user sessions
- def5678 Add cache warm-up on application start
- ghi9012 Fix edge case in cache TTL calculation
- jkl3456 Add integration tests for caching layer
- mno7890 Address review comments on PR #342

**org/api-service** (2 commits, +34/-8)
- pqr1234 Update API docs for rate limiting
- stu5678 Fix typo in error message

### PRs: 1 opened, 0 merged, 2 reviews submitted
### Linear: 2 issues moved to Done, 1 moved to In Review
```

---

## Cost Estimation for Developer Setup

| Component | Model | Frequency | Est. Cost/Month |
|-----------|-------|-----------|----------------|
| Heartbeat | Haiku 4 | Every 15 min (active hours) | $5-8 |
| PR reviews | Sonnet 4.6 | ~20 PRs/week | $15-25 |
| Morning digest | Sonnet 4.6 | Daily (weekdays) | $3-5 |
| Standup generation | Sonnet 4.6 | Daily (weekdays) | $3-5 |
| End-of-day summary | Sonnet 4.6 | Daily (weekdays) | $2-3 |
| CI health checks | Haiku 4 | Every 3 hours | $2-3 |
| Sprint summary | Sonnet 4.6 | Weekly | $1-2 |
| Ad-hoc queries | Sonnet 4.6 | ~20/week | $8-15 |
| **Total** | | | **$39-66/month** |

> **Tip**
>
> The biggest cost driver is PR reviews. To reduce costs: (1) skip reviews on draft PRs by adding a `skip_draft` option, (2) use Haiku for initial triage and only escalate to Sonnet for PRs with more than 200 lines changed, (3) exclude auto-generated files from reviews.

---

## Troubleshooting

### PR reviews are not appearing

- Verify the GitHub token has `repo` scope
- Check that the webhook is configured correctly (or that polling is enabled)
- Ensure the repos are listed in the `auto_review.repos` array
- Check that the jobs are running. There is no `cron history` and no `--last` flag; run history is `openclaw cron runs <job-id>`, and `openclaw cron list` shows the jobs themselves

### Standup is missing data

- Verify git repos are accessible with the configured token
- Check that Linear API key has read access to the team
- Ensure the `lookback_hours` is set correctly (24 for daily standups)
- If commits are not showing, verify the git author email matches

### CI alerts are delayed

- The CI monitor checks on heartbeat cycles. If your heartbeat is every 15 minutes, alerts may be delayed up to 15 minutes
- For faster alerts, either decrease the heartbeat interval or add a dedicated cron job that checks more frequently
- Verify the GitHub token has `actions:read` scope

### Linear sync is stale

- Check that the Linear API key has not expired
- Verify the `sync_interval_minutes` is not too high
- Ask for a sync in a turn. The skills CLI has no `run` subcommand: the page documents `search`, `install`, `update`, `verify`, `list`, `info`, `check`, `curator`, `library` and `workshop`. Use `openclaw agent --agent main --message "/linear-sync sync"`, where a "leading `/skill-name [input]`" is expanded "into model instructions to read the skill before acting"

---

## Next Steps

- **[Top 20 Skills](/docs/top-20-skills)** — Discover more developer-focused skills
- **[Multi-Agent Workflows](/docs/multi-agent-workflows)** — Set up agent teams for code review
- **[Heartbeat & Cron Configuration](/docs/heartbeat-config)** — Fine-tune your schedules
- **[Cost Optimization](/docs/cost-optimization)** — Reduce costs as you scale
- **[Security Hardening](/docs/security-hardening)** — Secure your GitHub tokens and API keys

## Sources

- [OpenClaw: Where things live on disk](https://docs.openclaw.ai/help/faq/where-things-live-on-disk)
- [OpenClaw: Agent workspace](https://docs.openclaw.ai/concepts/agent-workspace)
- [OpenClaw: Configuration reference](https://docs.openclaw.ai/gateway/configuration-reference)
- [OpenClaw: Configuration](https://docs.openclaw.ai/gateway/configuration)
- [OpenClaw: Skills CLI](https://docs.openclaw.ai/cli/skills)
- [OpenClaw: Configuration: agent models](https://docs.openclaw.ai/gateway/config-agents/models)
- [OpenClaw: Configuration: agent workspace and bootstrap](https://docs.openclaw.ai/gateway/config-agents/workspace-and-bootstrap)
- [OpenClaw: Skills config](https://docs.openclaw.ai/tools/skills-config)
- [OpenClaw: Configuration: MCP, skills, and plugins](https://docs.openclaw.ai/gateway/config-extensions)
- [OpenClaw: Configuration: per-agent entries and multi-agent routing](https://docs.openclaw.ai/gateway/config-agents/entries-and-multi-agent)
- [OpenClaw: Configuration: agent heartbeat, compaction, and streaming](https://docs.openclaw.ai/gateway/config-agents/heartbeat-compaction-and-streaming)
- [OpenClaw: Configuration: automations and media template variables](https://docs.openclaw.ai/gateway/config-automation)
- [OpenClaw: Automations (cron)](https://docs.openclaw.ai/cli/cron)
- [OpenClaw: Configuration: personal messaging channels](https://docs.openclaw.ai/gateway/config-channels/personal-messaging)
- [OpenClaw: Agent](https://docs.openclaw.ai/cli/agent)
- [ClawHub search API: exact-match query for github-bridge](https://clawhub.ai/api/v1/search?q=github-bridge&mode=exact)