It was a Monday morning, and our bug backlog had 34 items. By Tuesday morning, it had 27. Nobody on the team had touched it overnight. A Claude Code agent -- running on a scheduled cron job -- had picked the seven highest-priority bugs, analyzed the reproduction steps, written targeted fixes, pushed branches, and created merge requests with detailed descriptions. Three of those MRs were approved and merged before lunch.
This isn't science fiction or a polished demo. Autonomous AI agents that read a task board, write code, and create pull requests are already being used in production teams. A report from Anthropic on Claude Code's capabilities shows that AI agents can navigate codebases, run tests, and produce working fixes for well-defined bugs -- especially when given structured context like reproduction steps, error logs, and environment details.
The key insight is that the quality of the fix depends on the quality of the bug report. Feed an agent a vague "it's broken" and you'll get a vague fix. Feed it structured context from FlowBoard's bug fields -- reproduction steps, error messages, affected files, environment -- and you get a targeted, reviewable merge request. Here's how the whole pipeline works.
The agent runs a fully autonomous bug-fixing loop:
fix/#123_description)
The agent uses FlowBoard's REST API to read and update tasks. You'll need an API key from your workspace settings (Settings → API → Generate Key).
The agent's config file points to your workspace:
{ "flowboard": { "apiUrl": "https://europe-west3-flowwboard.cloudfunctions.net/api", "apiKey": "your-api-key", "workspaceId": "your-workspace-id", "projectId": "your-project-id" }, "gitlab": { "url": "https://gitlab.com", "token": "your-gitlab-pat", "projectId": "your-gitlab-project-id" } } With this configuration, the agent can query bugs, read task details (including bug context fields like reproduction steps, error messages, and environment), and update task status and assignee.
The heart of the system is flowboard-automation.js -- a Node.js script that orchestrates the entire workflow. It exposes several commands:
| Command | What It Does |
|---|---|
pick |
Finds the next unassigned bug and assigns it to the agent |
branch |
Creates a fix branch from the task number |
fix |
Invokes Claude to analyze and write the fix |
push |
Commits changes and pushes to GitLab |
mr |
Creates a merge request with task context in the description |
complete |
Updates FlowBoard status and adds a comment |
auto |
Runs the full loop: pick → branch → fix → push → mr → complete |
The auto command chains everything together. Point it at your repo, start it, and walk away.
The agent queries FlowBoard for unassigned bugs sorted by priority score. It selects the highest-priority bug and assigns itself as the owner via the API. Your custom priority formula determines which bugs the agent tackles first -- so make sure it reflects real urgency.
Using the task number and title, the agent creates a branch following FlowBoard's naming convention:
fix/#42_null_pointer_in_user_service_ai-agent This ensures the GitLab webhook automatically links the MR back to the FlowBoard task.
Claude reads the bug context from FlowBoard -- reproduction steps, error messages, affected files, environment details -- and uses this to locate the issue in the codebase. It then writes a targeted fix.
The agent commits the fix with a descriptive message, pushes to GitLab, and creates a merge request. The MR description includes:
Finally, the agent updates the task status in FlowBoard to "In Review" and adds a comment with the MR link. When your team reviews and merges the MR, FlowBoard's GitLab webhook automatically moves the task to "Done".
Getting started takes about 10 minutes:
npm install -g @anthropic-ai/claude-code
api and write_repository scopesflowboard-config.json in your project root with your API credentialsgit clone your-automation-repo cd flowboard-agent npm install
node flowboard-automation.js auto
Sometimes the agent encounters a bug that's missing critical information -- no reproduction steps, vague error descriptions, or unclear environment details. Instead of guessing, the agent can send a Slack message to the bug reporter asking for clarification. If you've already set up Slack or Teams notifications, these messages arrive in the same channels your team already watches.
Configure a Slack webhook in the config file, and the agent will:
Yes, for well-defined bugs with clear reproduction steps and error messages. AI agents are most effective with straightforward issues like null pointer errors, incorrect conditionals, missing validation, and off-by-one errors. Complex architectural bugs or issues requiring product judgment still need human developers, but an AI agent can meaningfully reduce the volume of routine fixes your team handles.
AI triage accuracy depends heavily on the quality of the bug report. With structured fields -- reproduction steps, error logs, environment details, and affected files -- AI agents can correctly identify the root cause and produce a working fix for the majority of well-documented, low-to-medium complexity bugs. Vague reports with no reproduction steps produce unreliable results regardless of whether a human or AI triages them.
Yes, and they should be taken seriously. When using AI agents, your source code and bug report data are sent to the AI provider's API. Review your provider's data retention and usage policies, ensure compliance with your organization's security requirements, and avoid including sensitive credentials or customer data in bug reports that the agent will process.
Avoid using AI agents for security-critical fixes, bugs that require understanding complex business logic, performance issues that need profiling and benchmarking, and any bug where the wrong fix could cause data loss. Start with low-risk, well-defined bugs and expand the agent's scope only after you've built confidence in its output through thorough code review.
Since this article was first published, we've released the FlowBoard MCP Server - a dedicated integration that lets Claude Code, Cursor, and other MCP-compatible tools connect to FlowBoard natively. Instead of writing custom API scripts, you configure one JSON block and your AI tool automatically discovers all FlowBoard operations: searching tasks, creating bugs, updating statuses, adding comments, and more.
The MCP server is now the recommended way to connect AI agents to FlowBoard. It uses the same API endpoints described in this article but wraps them in the standard MCP protocol, so any compatible tool can use them without custom code. Read the full setup guide to get started in 5 minutes.
AI agent automation turns FlowBoard into a self-healing system. Bugs come in, fixes go out -- automatically. Your team reviews merge requests instead of debugging, and your backlog shrinks while you focus on building features.
Combined with FlowBoard's GitLab integration (which auto-closes tasks on merge), you get a complete closed-loop: bug reported → agent fixes → MR created → team reviews → MR merged → task done. No manual updates anywhere in the chain. If this kind of automation interests you, start by writing better bug reports -- the agent is only as good as the context it receives. Read about handling urgent requests to understand how priority scoring determines what gets fixed first.