sdlcnext.com
← All tutorials
Claude Code Trello Agentic Workflows MCP

Build a Simple Trello Agentic Workflow with Claude Code

A step-by-step guide to building a Claude Code skill that pulls cards from Trello, implements them with an LLM, and ships, with human checkpoints baked in.

Install Claude Code

Claude Code is Anthropic’s official CLI for working with Claude from your terminal. Install it globally with npm:

npm install -g @anthropic-ai/claude-code

Then start it and authenticate:

claude

Follow the login prompt. You need an Anthropic account with API access.

Once installed, run claude from your project directory. That’s where all slash commands and skills will run. The workflow skill you’re about to build will be available in any Claude Code session on any machine where it’s installed.

Set up your Trello board

Create a Trello account at trello.com if you don’t have one. Create a new board for your project.

Add these five lists, in this order:

  • Backlog: everything that might eventually get done
  • Next: prioritised and ready to pull. The top card is what the agent picks up.
  • In Progress: card moves here when the agent starts work
  • In Review: card moves here when implementation is done, waiting for your sign-off
  • Done: card moves here after you approve and the code is pushed

Get your full board ID. Open the board in your browser. The URL looks like:

https://trello.com/b/AbCdEfGh/my-board-name

The short ID in the URL is not the full board ID. To get it, append .json to the board URL:

https://trello.com/b/AbCdEfGh/my-board-name.json

Find "id" at the top of the JSON. It looks like 69b95fe4db457a4a0a902023. That’s what you’ll hardcode into the skill.

Write cards with a clear brief. Each card in the Next list should have a descriptive name, a description that explains what to build, and optionally an “Acceptance Criteria” checklist for specific done conditions. The agent reads all of this. Vague cards produce vague output.

Get a Trello API key

Go to the Trello Power-Ups admin page: https://trello.com/power-ups/admin

Create a new Power-Up. This is how Trello issues API credentials, even for personal use.

Once created, click “API Key” in the sidebar to see your key. From the same page, click “Token” to generate a token with read/write access to your boards.

You need both values:

  • TRELLO_API_KEY
  • TRELLO_TOKEN

Keep these somewhere safe. You’ll supply them when configuring the MCP server in the next step.

Add the Trello MCP server

MCP (Model Context Protocol) servers give Claude Code access to external tools. The Trello MCP server exposes tools like get_cards_by_list_id, move_card, and add_comment that your skill will call.

Claude Code has a built-in command for adding MCP servers:

claude mcp add

When prompted:

  • Server name: trello
  • Transport type: stdio
  • Command: the command that starts the Trello MCP server binary

A common pattern using npx:

npx -y @modelcontextprotocol/server-trello

When prompted for environment variables, add your credentials:

TRELLO_API_KEY=your_key_here
TRELLO_TOKEN=your_token_here

Verify the server connected:

claude mcp list

You should see trello listed. If it’s there, the mcp__trello__* tools will be available in Claude Code sessions.

You can also edit ~/.claude/settings.json directly and add the MCP config under the mcpServers key. The claude mcp add command writes to the same file.

Create the workflow skill

Skills are markdown files stored in ~/.claude/skills/. Each skill becomes a slash command: a file at ~/.claude/skills/my-workflow/SKILL.md becomes /my-workflow in any Claude Code session.

Create the directory and file:

mkdir -p ~/.claude/skills/my-workflow
touch ~/.claude/skills/my-workflow/SKILL.md

A skill file has two parts: frontmatter and the prompt body.

Frontmatter declares the tools the skill is allowed to use:

---
name: my-workflow
version: 1.0.0
description: |
  Picks the top Trello card from Next, implements it, and ships.
  Usage: /my-workflow (no arguments needed)
allowed-tools:
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Bash
  - EnterPlanMode
  - ExitPlanMode
  - AskUserQuestion
  - mcp__trello__set_active_board
  - mcp__trello__get_lists
  - mcp__trello__get_cards_by_list_id
  - mcp__trello__get_card
  - mcp__trello__get_card_comments
  - mcp__trello__get_acceptance_criteria
  - mcp__trello__move_card
  - mcp__trello__add_comment
  - mcp__trello__update_checklist_item
---

The allowed-tools list is enforced. If a tool isn’t listed, Claude can’t use it even if it’s available in the session. Scope the skill to only what it needs.

Prompt body: everything after the frontmatter is the instruction set Claude follows when the skill runs.

Write the workflow steps

The prompt body is a numbered sequence of steps. Claude follows it literally. Here’s what each step does and how to write it.

Step 1: Connect to the board

Tell Claude to call set_active_board with your hardcoded board ID, then call get_lists and store the list IDs for Next, In Progress, In Review, and Done.

## STEP 1 — CONNECT TO THE BOARD

Call `set_active_board` with board ID `your_board_id_here`.
Then call `get_lists` and identify the IDs for:
- Next
- In Progress
- In Review
- Done

Store these IDs for use throughout the workflow.

Hardcode the board ID directly in the skill. It doesn’t change, and hardcoding it removes a whole class of errors where Claude tries to discover it dynamically and picks the wrong board.

Step 2: Read the top card

Tell Claude to call get_cards_by_list_id on the Next list, take the first card, then call get_card, get_card_comments, and get_acceptance_criteria. Have it print a one-paragraph summary of what it understood before doing anything else. This catches misreadings early.

Step 3: Move to In Progress

Call move_card with the card ID and the In Progress list ID.

Step 4: Create an implementation plan

The first place you’re in the loop. Call EnterPlanMode. Claude presents a plan and waits for your approval. Once you approve, it calls ExitPlanMode and proceeds.

EnterPlanMode is a Claude Code built-in that puts Claude into a plan-only state. It cannot edit files or run commands until you approve.

## STEP 4 — CREATE THE IMPLEMENTATION PLAN

Call `EnterPlanMode`. Create a plan covering:
- What files need to be created or modified
- The approach and key decisions
- Step-by-step implementation sequence
- How to verify the work is complete

Present the plan. Wait for user approval. Once approved, call `ExitPlanMode`.

Step 5: Log the plan to Trello

Before any implementation, call add_comment with the full plan. The card now has a record of what was planned, not just what was done.

Step 6: Execute

Tell Claude to carry out the plan. Include rules specific to your project:

Rules:
- Read reference files before writing new ones. Never write blind.
- Follow existing patterns and conventions.
- If you hit genuine ambiguity on a major decision, use AskUserQuestion.
- Run `npm run build` when done. Do not proceed if the build fails.

Step 7: Log the implementation to Trello

Call add_comment with a structured summary: files created, files modified, build result, and notes for the reviewer.

Step 8: Move to In Review

Call move_card with the In Review list ID.

Step 9: Pause for human review

The second place you’re in the loop. Claude presents a summary and stops, waiting for your feedback or an approval signal.

## STEP 9 — PAUSE FOR HUMAN REVIEW

Present:
- Card name
- 2-3 sentence summary of what was built
- Note that the card is now In Review

Ask: "What's your feedback?"

Stop here. Wait for the user's response.

Step 10: Review feedback loop

If the user gives feedback, Claude implements the changes, runs the build again, adds a comment documenting what changed, and returns to Step 9.

Define approval signals explicitly so Claude doesn’t have to guess:

Approval signals: "approved", "looks good", "ship it", "lgtm", "done", "yes",
or any clear positive confirmation. When in doubt, ask rather than assume.

Step 11: Ship

When approved:

  1. Stage implementation files with git add (never .env or secrets), commit with a descriptive message, push to main.
  2. Call add_comment with a “Shipped.” summary and the commit hash.
  3. Call move_card to move the card to Done.
  4. If the card had checklist items, mark each complete with update_checklist_item.

Run the skill

In your project directory:

claude

Then type:

/my-workflow

Claude starts the workflow from Step 1. You’ll be prompted at plan approval and again at the review step. Everything else runs without you.

The whole flow, from picking up the card to pushing the commit, runs without you except at two points: approving the plan, and approving the output.

Adapt and extend

Hardcode the board ID. It doesn’t change, and letting Claude discover it dynamically is a reliable way to pick the wrong board.

Use EnterPlanMode for the planning step. Without it, Claude often skips straight to implementation when the task looks simple enough. Plan mode is a hard stop — there’s no way for it to write a file until you say yes.

Log to Trello at every stage. The card ends up as a complete record: what was planned, what was built, every review round, the shipped commit hash. That history is on the card, not buried in a conversation you’ll never find again.

Define approval signals explicitly. Claude will sometimes treat “ok fine” or “yeah that works” as approval when you meant something more tentative. Give it a defined list and it follows the rule.

The read-card, plan, implement, review, ship loop is the same for any project. What changes is the execution step. Swap out npm run build for cargo build, pytest, go test ./..., or whatever your verification command is. Replace the file-writing rules with conventions from your own codebase. Add project-specific tools to allowed-tools if you need them. The skill here is specific to an Astro site with npm, but the structure isn’t.

File layout:

~/.claude/
  skills/
    my-workflow/
      SKILL.md          # the skill definition
  settings.json         # global Claude Code settings, MCP server config

The skill is global, available in any Claude Code session on any project. If you want it scoped to one repo, put it in .claude/skills/ at the project root instead.

Comments

Loading comments…

Leave a comment