Superagents: How ClickUp and Clawdup Enable Continuous Project Improvement

What if your project could improve itself? Not just execute one task at a time, but continuously analyze its own codebase, identify improvements, and create tasks to implement them — all without human intervention. That's exactly what happens when you combine ClickUp superagents with clawdup.

In this guide, we'll walk through everything from signing up for ClickUp to setting up clawdup to creating your first superagent that keeps your project getting better on its own.

What Are Superagents?

A superagent is a ClickUp Automation that acts as a project manager for your codebase. Instead of a human reviewing the project and filing improvement tasks, a superagent does it automatically. It can:

• Analyze your codebase and identify areas for improvement
• Create ClickUp tasks with detailed descriptions of what to change
• Prioritize tasks based on impact and complexity
• Continuously run on a schedule to keep finding new improvements

When paired with clawdup, those tasks get automatically picked up, implemented by Claude Code, and turned into pull requests. The result is a continuous improvement loop: the superagent creates tasks, clawdup implements them, you review and merge the PRs, and the superagent finds the next round of improvements.

Part 1: Setting Up ClickUp

Step 1: Sign up for ClickUp

If you don't already have an account, head to clickup.com and sign up. The free tier works perfectly for this workflow. Here's what to do:

1. Create an account with your email or sign in with Google/GitHub
2. Create a new Workspace (or use an existing one)
3. Create a new Space for your project — name it after your repository

Step 2: Create a List with the right statuses

clawdup relies on specific task statuses to manage the automation lifecycle. Create a new List inside your Space and configure these statuses:

• to do — Tasks waiting to be picked up
• in progress — Currently being implemented by clawdup
• in review — PR created, waiting for human review
• approved — Reviewed and ready to merge
• complete — Merged and done
• blocked — Something went wrong during implementation
• require input — The AI needs clarification before proceeding

You can also use clawdup's built-in setup wizard to create a list with these statuses automatically — more on that in Part 2.

Step 3: Get your API credentials

You'll need two things from ClickUp:

1. API Token: Go to Settings → Apps → API Token. Generate a personal token.
2. List ID: Navigate to your list, click the three-dot menu, and select "Copy Link." The List ID is the number at the end of the URL. Alternatively, you can paste the full link when configuring clawdup — it will extract the ID automatically.

Part 2: Setting Up Clawdup

Step 1: Install clawdup

clawdup is available on npm. Install it globally:

npm install -g clawdup

Step 2: Prerequisites

Make sure you have these tools installed and configured:

• Node.js 18+ — clawdup uses native fetch
• Git — for branching, committing, and pushing
• GitHub CLI (gh) — for creating pull requests. Run gh auth login to authenticate.
• Claude Code CLI (claude) — the AI engine that implements tasks. Install it and authenticate with your Anthropic API key.

You can verify everything is ready by running:

clawdup --check

This checks for all required tools and reports any missing dependencies.

Step 3: Initialize your project

Navigate to your project's root directory and run the setup wizard:

cd your-project
clawdup --setup

The wizard will prompt you for:

• Your ClickUp API token
• Your ClickUp List ID (or a link to the list)
• Whether to create a list with default statuses (if you haven't already)

This creates a .clawdup.env file in your project root with the configuration. Make sure to add .clawdup.env to your .gitignore — it contains your API token.

Step 4: Add a CLAUDE.md file

This is the secret sauce. Create a CLAUDE.md file in your project root that describes your project's architecture, coding conventions, and any important context. Claude Code reads this file before implementing any task, ensuring the generated code matches your project's style.

A good CLAUDE.md includes:

• Tech stack and language version
• Project structure overview
• Naming conventions and coding standards
• How to build and test the project
• Key architectural decisions

Step 5: Start clawdup

Run clawdup in your project directory:

clawdup

It will start polling your ClickUp list for tasks with "to do" status. When it finds one, it creates a branch, invokes Claude Code, commits the changes, and creates a PR. The entire pipeline runs autonomously.

Part 3: Creating a Superagent

Now for the exciting part. A superagent turns this from a "run tasks" tool into a "continuously improve your project" engine.

The concept

A superagent is a ClickUp Automation that periodically creates improvement tasks in your clawdup-monitored list. It uses ClickUp's built-in AI capabilities to analyze your project and generate actionable tasks.

Step 1: Create the Automation

In your ClickUp Space, go to Automations and create a new automation:

1. Trigger: Set it to run on a schedule — daily, weekly, or whatever cadence makes sense for your project
2. Action: Create a task in your clawdup-monitored list

Step 2: Define improvement categories

The most effective superagents focus on specific improvement categories. Create separate automations for each category:

• Code quality: "Review the codebase for code smells, duplicated logic, or functions that are too long. Create a task to refactor the worst offender."
• Documentation: "Find functions or modules that are missing documentation. Create a task to add JSDoc comments to the least-documented file."
• Testing: "Identify modules with no test coverage. Create a task to add unit tests for one untested module."
• Performance: "Look for obvious performance issues like N+1 queries, unnecessary re-renders, or missing caching. Create a task to fix one."
• Security: "Scan for common security issues — hardcoded values that should be environment variables, missing input validation, or outdated patterns. Create a task to fix one."

Step 3: Write effective superagent prompts

The key to a good superagent is writing task descriptions that give clawdup enough context to do useful work. Here's a template:

Review [specific area] of the codebase and [specific action].

Focus on:
- [Criterion 1]
- [Criterion 2]
- [Criterion 3]

Constraints:
- Only change one file per task
- Follow existing coding conventions in CLAUDE.md
- Do not introduce new dependencies

For example, a code quality superagent might create tasks like:

Review src/ for functions longer than 50 lines and refactor
the longest one into smaller, well-named helper functions.

Focus on:
- Maintaining the same public API
- Adding clear function names that describe what each piece does
- Keeping related logic together

Constraints:
- Only refactor one function per task
- Do not change any exported function signatures
- Ensure TypeScript strict mode still passes

Step 4: Control the pace

You don't want the superagent to flood your list with tasks. Use these strategies to keep it manageable:

• Schedule wisely: Start with one task per day and adjust based on your review capacity
• Add conditions: Only create a new task if there are fewer than 3 tasks with "to do" status in the list
• Rotate categories: Monday = code quality, Tuesday = docs, Wednesday = tests, etc.
• Set limits: Use ClickUp's automation conditions to cap the total number of open tasks

The Continuous Improvement Loop

When everything is connected, here's what happens:

1. The superagent runs on schedule and creates a task: "Add error handling to the database module"
2. clawdup picks up the task, creates a branch, and invokes Claude Code
3. Claude Code reads the codebase, implements the changes, and clawdup creates a PR
4. A human reviewer approves or requests changes
5. clawdup merges the PR when approved
6. The superagent runs again and identifies the next improvement

Each cycle makes the codebase a little better. Over days and weeks, the compound effect is significant — better test coverage, cleaner code, more documentation, fewer security issues.

Real-World Tips

Start small

Begin with one superagent focused on a single category (documentation is a great starting point). Watch how it performs for a week before adding more.

Always review the PRs

Superagents are powerful, but they're not infallible. Every PR still goes through human review. The automation handles the tedious work; you provide the judgment.

Refine your CLAUDE.md

The quality of generated code depends heavily on your CLAUDE.md file. As you review PRs, note any patterns the AI gets wrong and add explicit guidance to CLAUDE.md. The better your project description, the better the output.

Use task templates

ClickUp supports task templates. Create templates for common improvement patterns so your superagent automations produce consistent, well-structured tasks.

Monitor and adjust

Check the "blocked" and "require input" statuses regularly. These indicate tasks that the AI couldn't handle — they're valuable feedback for improving your superagent prompts and CLAUDE.md.

What's Possible

Teams using this pattern report:

• Test coverage increasing steadily without dedicated testing sprints
• Documentation staying up-to-date as the codebase evolves
• Code quality metrics improving week over week
• Developers spending less time on routine maintenance and more on creative work

The superagent pattern isn't about replacing developers — it's about giving your codebase a tireless assistant that handles the improvements everyone knows should happen but nobody has time for. You stay in control of what gets merged. The automation just makes sure the work gets done.