Most people look at Cline Kanban and see a board. Cards, columns, drag and drop. But Kanban isn't a project management tool. It's an orchestration layer for coding agents, one with a particularly robust feature: the Kanban Agent in sidebar chat is where the real leverage lives.
One prompt in the Kanban Agent can decompose a complex project into linked task cards, fan them out for parallel execution across multiple agents, and chain them so one finishing triggers the next. The result is end-to-end autonomous workflows that go from a single sentence to committed code across your entire codebase.
We put together 20 starter prompts across five categories. Each one is copy-paste ready for the Kanban sidebar chat. They create linked dependency chains, maximize parallel agent execution, and produce real, working code. Install with npm i -g cline, run cline in any project directory, and try them.
Kanban sidebar agent creating linked task cards from a single prompt
Greenfield app scaffolding
These prompts build new projects from scratch. The key pattern: set up the foundation first, then fan out parallel tasks for features that don't depend on each other.
1. Express API from scratch
Build a production-ready Express API for this project. Break it into
tasks: 1) Set up Express with TypeScript, tsconfig, and a dev script
with nodemon 2) Add a health check endpoint at GET /health returning
{ status: "ok", timestamp } 3) Add structured JSON logging with pino
4) Add global error handling middleware with proper error response
format 5) Add CORS and helmet security middleware. Link them
sequentially -- each builds on the last. Start task 1.
2. React + Vite frontend
Scaffold a React frontend with Vite for this project. Tasks: 1)
Initialize Vite with React and TypeScript template, add path aliases
in tsconfig and vite.config 2) Set up React Router with a layout
component, home page, and 404 page 3) Add a reusable component
library -- Button, Card, Input, Modal -- in src/components/ui with
basic styling 4) Add a dark/light theme provider using CSS variables
and React context. Link 1 → 2 → 3, and 1 → 4 so theming and
components run in parallel after routing is set up. Start task 1.
3. CLI tool
Build a Node.js CLI tool in this repo. Tasks: 1) Set up the project
with TypeScript, a bin entry in package.json, and commander.js for
argument parsing 2) Add a "init" command that scaffolds a config file
interactively using prompts 3) Add a "run" command that reads the
config and executes the main logic with a progress spinner using ora
4) Add colorized output with chalk and a --verbose flag for debug
logging. Link 1 → 2, 1 → 3, and 1 → 4 so all three commands build in
parallel after setup. Start task 1.
⭐ 4. Full-stack with database – A single prompt gives you a typed Express API backed by SQLite with full CRUD, input validation, and seed data. Five linked tasks, two parallel branches.
Set up a full-stack app with Express backend and SQLite database.
Tasks: 1) Initialize Express with TypeScript and install better-
sqlite3 2) Create a database module in src/db.ts that initializes
SQLite, creates a "users" table with id, name, email, created_at 3)
Add CRUD API routes: GET /users, GET /users/:id, POST /users, PUT
/users/:id, DELETE /users/:id 4) Add input validation middleware
using zod schemas for the POST and PUT routes 5) Add seed script that
populates 10 sample users. Link 1 → 2 → 3 → 4, and 2 → 5 so seeding
runs in parallel with route development. Start task 1.
Codebase modernization and migration
Legacy code is where Kanban's parallel execution really shines. These prompts audit first, then fan out multiple refactoring tasks simultaneously.
5. JavaScript to TypeScript migration
Migrate this JavaScript project to TypeScript. Tasks: 1) Add
tsconfig.json with strict mode, install typescript and ts-node,
rename entry point to .ts 2) Rename all .js files in src/ to .ts and
fix immediate type errors with explicit type annotations 3) Add type
definitions for all function parameters and return types across the
codebase 4) Replace any require() calls with ES module imports and
update package.json with "type": "module" if needed 5) Add a build
script using tsc and verify the compiled output runs correctly. Link
sequentially 1 → 2 → 3 → 4 → 5. Start task 1.
6. Dependency audit and upgrade
Audit and upgrade dependencies in this project. Tasks: 1) Run npm
outdated, identify all packages with major version bumps, and create
a report as UPGRADE_PLAN.md listing each package, current version,
target version, and known breaking changes 2) Upgrade all non-
breaking minor and patch versions across the project 3) Upgrade major
version packages one at a time, fixing breaking changes in the code
after each upgrade 4) Remove any unused dependencies identified by
depcheck. Link 1 → 2, 1 → 3, and 1 → 4 so cleanup and upgrades run in
parallel after the audit. Start task 1.
⭐ 7. Add ESLint and Prettier -- This prompt runs two completely independent tooling setups in parallel, then applies each tool's auto-fixes in separate worktrees. Zero conflicts because each agent works in isolation.
Add code quality tooling to this project. Tasks: 1) Install and
configure ESLint with a flat config file using @eslint/js and
typescript-eslint, with rules for no-unused-vars, consistent-return,
and no-console as warnings 2) Install and configure Prettier with a
.prettierrc that uses single quotes, no semicolons, and 2-space tabs
3) Run eslint --fix across the entire codebase and commit the auto-
fixed changes 4) Run prettier --write across the entire codebase and
commit the formatted changes. Link 1 → 3 and 2 → 4 so linting and
formatting run in parallel. Start tasks 1 and 2.
8. Extract shared utilities
Refactor this codebase to extract duplicated logic. Tasks: 1) Scan
the codebase for duplicated patterns -- repeated validation logic,
string formatting, date handling, error construction -- and list them
in a REFACTOR_PLAN.md 2) Create a src/utils/ directory with modules
for each identified pattern: validation.ts, format.ts, dates.ts,
errors.ts 3) Replace all duplicated code across the codebase with
imports from the new utility modules 4) Add unit tests for each
utility module using the existing test framework. Link 1 → 2 → 3, and
2 → 4 so tests and refactoring run in parallel. Start task 1.
Testing and quality
Testing is one of the highest-value uses for Kanban because unit tests, integration tests, and documentation are naturally independent -- they fan out perfectly.
⭐ 9. Comprehensive test suite -- Four tasks, but the real magic is the linking pattern: unit tests and integration tests build simultaneously after the test framework is configured, then converge on the CI coverage gate.
Add a test suite to this project. Tasks: 1) Install and configure
vitest with TypeScript support, add test and test:coverage scripts to
package.json 2) Write unit tests for all utility functions and helper
modules in src/utils or src/lib, aiming for 100% coverage on those
files 3) Write integration tests for all API routes using supertest,
covering success cases and error cases 4) Add a test:ci script that
runs tests with coverage and fails if coverage drops below 80%. Link
1 → 2 and 1 → 3 so unit and integration tests build in parallel, then
2 → 4 and 3 → 4 so the CI script comes last. Start task 1.
10. API documentation
Document all APIs in this project. Tasks: 1) Install swagger-jsdoc
and swagger-ui-express, configure them to serve docs at /api-docs 2)
Add JSDoc annotations with @swagger tags to every route handler
documenting the method, path, parameters, request body schema, and
response schema 3) Add example request/response payloads for each
endpoint in the swagger annotations 4) Add a README section
documenting how to access the API docs locally and listing all
available endpoints with brief descriptions. Link 1 → 2 → 3, and run
4 in parallel after 1. Start task 1.
11. Error handling hardening
Harden error handling across this codebase. Tasks: 1) Create a custom
AppError class in src/errors.ts that extends Error with statusCode,
isOperational, and context fields, plus factory functions for
notFound, badRequest, unauthorized, and internal errors 2) Add an
Express error-handling middleware that catches AppError instances and
returns structured JSON error responses with appropriate status codes
3) Audit every route handler and replace raw throw/try-catch patterns
with the new AppError classes 4) Add a process-level uncaught
exception and unhandled rejection handler that logs and gracefully
shuts down. Link 1 → 2 → 3, and 1 → 4 in parallel. Start task 1.
12. Add logging and observability
Add structured logging to this application. Tasks: 1) Install pino
and pino-http, create a logger module in src/logger.ts that outputs
JSON logs with configurable log levels via LOG_LEVEL env var 2) Add
request logging middleware using pino-http that logs method, url,
status code, and response time for every request 3) Add contextual
logging to all existing route handlers and service functions -- log
on entry, on error, and on completion with relevant context like user
IDs or resource IDs 4) Add a correlation ID middleware that generates
a UUID per request and attaches it to all log lines for that request.
Link 1 → 2 and 1 → 4 in parallel, then 2 → 3 and 4 → 3 so the route
logging comes last. Start task 1.
Feature development
These prompts add real product features. The linking patterns here are more complex because features have more interdependencies -- but Kanban handles the orchestration.
⭐ 13. Authentication system -- This is the most complex single prompt in the collection. Five tasks, three parallel branches, a convergence point. One sidebar message gives you a complete auth system with registration, login, JWT middleware, and route protection.
Add JWT authentication to this Express app. Tasks: 1) Install
jsonwebtoken and bcryptjs, create a src/auth/ directory with modules
for password hashing and JWT token generation/verification with
configurable secret and expiry via env vars 2) Add POST
/auth/register endpoint that validates email/password, hashes the
password, stores the user, and returns a JWT 3) Add POST /auth/login
endpoint that validates credentials, compares the password hash, and
returns a JWT 4) Add an auth middleware that extracts the JWT from
the Authorization header, verifies it, and attaches the user to
req.user 5) Protect all existing routes except /health and /auth/*
with the auth middleware. Link 1 → 2, 1 → 3, 1 → 4 so register,
login, and middleware build in parallel, then 2 → 5, 3 → 5, 4 → 5 so
route protection comes last. Start task 1.
14. Search and filtering
Add search and filtering to the existing list endpoints in this API.
Tasks: 1) Create a query parser utility in src/utils/query.ts that
extracts page, limit, sort, order, and arbitrary filter fields from
req.query with sensible defaults and validation 2) Update the GET
list endpoints to accept ?search= parameter that does a case-
insensitive partial match across text fields 3) Add pagination
support -- return results with { data, total, page, limit, totalPages
} response format 4) Add sort support with ?
sort=field&order=asc|desc. Link 1 → 2, 1 → 3, 1 → 4 so search,
pagination, and sorting build in parallel after the query parser.
Start task 1.
15. File upload endpoint
Add file upload capability to this Express app. Tasks: 1) Install
multer and configure it with disk storage in an uploads/ directory,
10MB file size limit, and allowed extensions for images (jpg, png,
gif, webp) 2) Add POST /upload endpoint that accepts a single file,
validates it, stores it, and returns { filename, originalName, size,
mimetype, url } 3) Add GET /uploads/:filename endpoint that serves
the uploaded file with proper content-type headers and 404 handling
4) Add a cleanup utility that deletes uploaded files older than 30
days, callable via a DELETE /uploads/cleanup endpoint. Link 1 → 2 →
3, and 1 → 4 in parallel. Start task 1.
16. WebSocket real-time updates
Add WebSocket support to this Express app for real-time updates.
Tasks: 1) Install ws, integrate a WebSocket server with the existing
HTTP server, and create a connection manager in src/ws.ts that tracks
connected clients by ID 2) Add a broadcast utility that sends a JSON
message to all connected clients or to specific client IDs 3) Modify
the existing POST, PUT, and DELETE route handlers to emit WebSocket
events after successful mutations -- e.g., { event: "user:created",
data: user } 4) Add a heartbeat ping/pong mechanism that detects and
cleans up stale connections every 30 seconds. Link 1 → 2 → 3, and 1 →
4 in parallel. Start task 1.
DevOps and infrastructure
Infrastructure tasks are often tedious and repetitive. They're also perfectly suited for parallel execution because a Dockerfile, a CI config, and a .dockerignore don't depend on each other.
17. Dockerize the application
Dockerize this application. Tasks: 1) Create a multi-stage Dockerfile
with a builder stage that installs deps and compiles TypeScript,
production stage that copies only compiled output and production
deps, runs as non-root user on port 3000 2) Create a docker-
compose.yml with the app service, health check, environment variables
from .env, and a volume mount for uploads if applicable 3) Add a
.dockerignore file excluding node_modules, .git, .env, dist, and test
files 4) Add npm scripts: docker:build, docker:run, docker:stop and
document them in the README. Link 1 → 3 in parallel (both are
independent files), then 1 → 2 → 4 for the compose and docs. Start
tasks 1 and 3.
⭐ 18. GitHub Actions CI/CD -- Four tasks, three running in parallel from the start. CI workflow, release workflow, and contributing docs all build simultaneously, then converge on adding README badges. This is the kind of infrastructure setup that normally takes an afternoon -- Kanban does it in minutes.
Add GitHub Actions CI/CD to this project. Tasks: 1) Create
.github/workflows/ci.yml that runs on push and PR to main -- checks
out code, installs deps, runs linting, runs tests with coverage, and
fails if coverage is below threshold 2) Create
.github/workflows/release.yml that runs on tags matching v* -- builds
the project, creates a GitHub release with auto-generated notes 3)
Add a branch protection rules recommendation in CONTRIBUTING.md
documenting that main requires CI to pass 4) Add status badges for CI
workflow to the top of README.md. Link 1 → 4 and 2 → 4 so badges come
after both workflows exist. Run 1, 2, and 3 in parallel. Start all
tasks.
19. Environment configuration
Add proper environment configuration to this project. Tasks: 1)
Install dotenv, create a src/config.ts module that loads and
validates all environment variables with defaults, exports a typed
config object -- include PORT, NODE_ENV, LOG_LEVEL, DATABASE_URL,
JWT_SECRET 2) Create .env.example with all required variables and
placeholder values, add .env to .gitignore 3) Replace all process.env
references scattered across the codebase with imports from the config
module 4) Add a startup validation that checks all required env vars
are present and logs which are missing with a clear error message
before the app exits. Link 1 → 2 and 1 → 3 in parallel, then 3 → 4.
Start task 1.
20. Monorepo setup
Convert this project into a monorepo. Tasks: 1) Install and configure
Turborepo with a root turbo.json, move the existing app code into
packages/api, update all paths and imports accordingly 2) Create
packages/shared with common TypeScript types, utility functions, and
constants that will be shared across packages 3) Create packages/web
as a minimal React + Vite frontend that imports types from
packages/shared 4) Configure the root package.json with workspace
scripts: dev (runs all packages), build (builds all), test (tests
all), and lint (lints all). Link 1 → 2, 1 → 3 in parallel (both
depend on the monorepo structure), then 2 → 4 and 3 → 4 so workspace
scripts come after all packages exist. Start task 1.
Now show us yours
These 20 prompts are starting points. The real creative potential is in the workflows you build for your own projects -- the migration scripts nobody else has thought of, the testing patterns specific to your stack, the infrastructure recipes that save your team hours every week.
We want to see what you come up with. Share your best one-shot Kanban prompts with #OneShotShip on Twitter/X, or post them in our Discord and Reddit. Tag us at Cline so we can find them. The most creative and effective prompts will get featured in future Cline content.
And if you're building open source tools, workflows, or integrations on top of Kanban, our $1M open source grant program is accepting applications. Build something great and get funded to keep going.
Get started:
npm i -g cline
cline
Top comments (0)