How I Let AI Agents Clear My Backlog Overnight

Introduction

I had 23 tasks in my backlog. I wrote clear descriptions for each, connected Claude Code to FlowBoard via MCP, and went to bed. By morning, several had branches with code changes. Some needed work, others were surprisingly close to mergeable. Here's what I learned.

This isn't a hypothetical workflow or a conference demo. It's what happens when you combine a well-structured task board with an AI coding agent that knows how to read it. The agent picks up tasks, understands the requirements, writes code, pushes branches, creates pull requests, and updates your board -all while you're asleep.

This is what vibe coding looks like at scale -you describe, AI builds, the board tracks. The trick isn't the AI. The trick is writing tasks that an agent can actually execute. Here's exactly how I set it up, what worked, and what still needs a human.

The Setup

You need three things to get this running:

1. A FlowBoard workspace with tasks that have clear descriptions and acceptance criteria
2. A FlowBoard API key from Settings → API → Generate Key
3. Claude Code with MCP configured to talk to FlowBoard

The MCP configuration is a single JSON block in your project's .mcp.json:

{
  "mcpServers": {
    "flowboard": {
      "command": "node",
      "args": ["./mcp-servers/build/flowboard-server.js"],
      "env": {
        "FLOWBOARD_API_URL": "https://europe-west3-flowwboard.cloudfunctions.net/api",
        "FLOWBOARD_API_KEY": "your-api-key",
        "FLOWBOARD_WORKSPACE_ID": "your-workspace-id"
      }
    }
  }
}

Once configured, Claude Code can discover all FlowBoard operations natively -searching tasks, reading details, updating statuses, and adding comments. No custom scripts needed for the basic integration.

Writing Agent-Friendly Tasks

This is where most people fail. They write tasks for humans -with implied context, vague requirements, and assumptions about what "done" means. Agents need explicit instructions.

An agent-friendly task has:

• A specific title: "Fix null check in UserService.getProfile()" not "User profile sometimes crashes"
• Clear acceptance criteria: Numbered list of what must be true when the task is done
• File hints: Which files are likely involved (the agent can find others, but hints save time)
• Bug context fields: For bugs, fill in reproduction steps, error messages, environment details, and affected components
• Expected behavior: What should happen after the fix, not just what's broken

Here's a real example of a task description that an agent executed successfully:

## Description
The workspace settings page throws a TypeError when a user with no
avatar URL opens the members list. The avatar component expects a
string but receives undefined.

## Acceptance Criteria
1. Members list renders without errors when a user has no avatar URL
2. A default placeholder avatar is shown for users without avatars
3. Existing avatars continue to display correctly
4. No TypeScript errors or warnings

## File Hints
- src/app/pages/settings/members-list.component.ts
- libs/ui/src/lib/avatar/avatar.component.ts

## Error
TypeError: Cannot read properties of undefined (reading 'charAt')
  at AvatarComponent.getInitials (avatar.component.ts:24)

The Agent Loop

The agent follows a simple, repeatable loop. Each iteration handles one task from start to finish.

1. Fetch open tasks: The agent queries FlowBoard for unassigned tasks sorted by priority.

   GET /api/getTasks?status=open&assignee=unassigned&sort=priority&limit=5
   Authorization: Bearer your-api-key

2. Claim a task: The agent assigns itself and moves the task to in progress.

   PATCH /api/updateTask
   {
     "taskId": "task-123",
     "workspaceId": "ws-456",
     "status": "in_progress",
     "assignee": "ai-agent"
   }

3. Read the task context: Parse the description, acceptance criteria, bug context fields, and file hints. Build a prompt with the full context.
4. Write the fix: Using Claude's code understanding, the agent navigates the codebase, identifies the relevant files, and writes the changes.
5. Push code and create PR: The agent commits changes to a new branch, pushes to GitHub/GitLab, and creates a pull request with the FlowBoard task link in the description.
6. Update FlowBoard: Move the task to "In Review" and add a comment with the PR link.

   PATCH /api/updateTask
   {
     "taskId": "task-123",
     "workspaceId": "ws-456",
     "status": "in_review"
   }
   
   POST /api/addComment
   {
     "taskId": "task-123",
     "workspaceId": "ws-456",
     "comment": "PR created: https://github.com/org/repo/pull/87"
   }

7. Repeat: Pick the next task and start again.

Results After One Week

After running the agent every night for a week, here's a rough picture of how it went:

• Tasks attempted per night: Varied widely depending on complexity, usually a handful
• PR quality: Majority needed at least minor edits. A good chunk were mergeable with small tweaks, some needed significant rework, and a few had to be scrapped entirely
• Best task types: Bug fixes with clear reproduction steps, small chores (rename, refactor, update dependency), well-scoped features with explicit acceptance criteria
• Net effect: Freed up several hours of developer time per week on routine tasks -not a magic bullet, but a meaningful dent in the backlog

The agent was most effective with tasks that had structured bug context -reproduction steps, error messages, and file hints. These had the highest merge rate. Tasks with vague descriptions like "improve performance" or "clean up the code" produced the lowest quality results.

What Doesn't Work Yet

Not every task belongs on the agent's plate. Here's what consistently fails or produces low-quality results:

• Complex features requiring design decisions: If the task needs product judgment about UX, information architecture, or user flows, the agent will make arbitrary choices that usually aren't right
• Tasks with unclear scope: "Improve the dashboard" gives the agent no signal about what "improved" means. It'll change things, but not necessarily the right things
• Cross-cutting refactors: Large-scale changes that touch many files and require understanding of the full system architecture are risky to automate
• Security-sensitive code: Authentication, authorization, encryption, and anything involving credentials should always have human review before the agent touches it
• Performance optimization: Requires profiling, benchmarking, and understanding of runtime behavior that the agent can't observe
• Tasks with vague descriptions: If you write "fix the bug" without reproduction steps, environment info, and expected behavior, the agent will guess -and guess wrong. The quality of your task description IS the prompt

The rule of thumb: if you can write a complete description with clear acceptance criteria in under 5 minutes, the agent can probably handle it. If the description requires a design discussion, keep it for humans.

Tips for Getting Started

1. Start with bug fixes: They're the most well-defined task type. FlowBoard's bug context fields (reproduction steps, error messages, environment) give the agent exactly what it needs
2. Use the bug context fields: Don't put everything in the description. Use the structured fields -the agent parses them separately and weights them higher
3. Keep tasks atomic: One task = one change. Don't combine "fix the login bug AND add a loading spinner" into one task
4. Review everything before merging: The agent creates PRs for review, not auto-merged commits. Treat agent PRs like any other team member's code
5. Use the MCP Server for the easiest setup: It handles all the API communication and lets Claude Code discover FlowBoard operations automatically
6. Check the agent's work in the morning: Spend 30 minutes reviewing the night's PRs. Approve the good ones, close the bad ones, and improve the task descriptions for next time
7. Iterate on task quality: The agent's output quality is directly proportional to your task description quality. When a PR gets rejected, ask why and improve the task template

Conclusion

The overnight AI dev team isn't about replacing developers. It's about letting developers focus on the work that requires human judgment while routine tasks get handled automatically. Bug fixes, chores, well-defined features -these eat up hours every week. An agent can knock them out while you sleep.

The key is task quality. Write clear descriptions, use structured fields, keep tasks atomic, and review everything. Start with 5 well-written bug reports, let the agent run overnight, and see what comes back. You might be surprised how many are ready to merge by morning.