Introducing Worklist: An Issue Tracker Built for AI Agents

Here's the problem with every issue tracker that exists today. They were all designed for the same workflow: a human writes a description, other humans discuss it in comments, someone eventually picks it up and builds it. The issue is a communication tool. It's optimised for context-sharing between people.

That workflow made sense when people were the ones writing the code. It makes less sense when an AI agent is.

An AI agent doesn't need a comment thread. It doesn't need a discussion about scope. It needs structured data: what to build, what done looks like, which files to inspect, and any constraints to follow. Give it that, and it has a much better chance of going from task to useful pull request without a long setup conversation.

That's what Worklist is. An issue tracker where every item is an execution packet for an AI agent, not a to-do item for a human.

What a work unit looks like

The basic building block is a work unit. It has:

Title and description. Same as any issue tracker. What needs to happen and why.

Structured acceptance criteria. Not a paragraph buried in the description. Checkable items that define what "done" means. "Rate limit middleware applied to all /api/v1 routes." "Return 429 with Retry-After header when exceeded." "Document the new limits in the API reference." The agent knows exactly what to achieve, and completion is verifiable against the criteria.

File scope. A list of files the agent should focus on. app/Http/Middleware/, routes/api.php, config/rate-limits.php. This is the difference between an agent that searches the entire codebase guessing where to make changes and one that knows exactly where to look. It dramatically improves output quality and reduces wasted tokens.

Size classification. Single pass (the agent can do it in one go), multi-step (might need multiple iterations), or spike (research/investigation, not implementation). This helps with estimation and with choosing the right agent for the job.

Human notes. A structured field for course correction. If the agent's first attempt wasn't quite right, you add notes explaining what to change and re-delegate. The notes go into the next prompt automatically.

Agent reports. When a work unit is delegated, the resulting report can capture what happened: decisions made, files changed, issues encountered. This builds a history of the work, not just the outcome.

Built for delegation

Worklist is designed around delegation. Not just "assign to a person." Hand the work to a coding agent.

When a work unit is ready, its description, acceptance criteria, file scope, and human notes can be assembled into the agent prompt automatically. You don't rewrite the issue as a prompt. The structured data is the prompt.

That same structure gives Shipchart a clean lifecycle to track: open, delegated, in review, done, or blocked. As the agent workflow runs, the work unit remains the source of truth for what was asked, what changed, and what still needs a human look.

If the first attempt needs adjustment, add human notes and delegate again. The agent gets the original context plus your corrections. Each iteration gets better because the context accumulates.

Work units appear from everywhere

Worklist isn't just a place to manually create issues. Work units flow in from multiple sources:

Roadmap breakdown. When you decompose a feature on your roadmap into work items, those become work units with full context inherited from the parent feature.

Error detection. Unresolved production errors can become work units with the error data, stack trace, and affected files pre-filled. An error goes from "something broke" to "delegatable fix" in seconds.

Deep Plan. Shipchart's codebase-aware planning tool explores your repo and generates work units with file scope and acceptance criteria already populated based on what it finds in the code.

MCP tools. MCP-connected AI assistants can create work units via the API. You're in a conversation, you identify a task, the AI creates the work unit directly. No context switch.

Ad-hoc delegation. Sometimes you just want to hand off something quickly without creating a formal work unit first. Quick delegation creates a backing work unit automatically so there's always a record.

Manual creation. Web, API, or CLI. The traditional way still works fine for when you want to create something by hand.

Every source feeds into one unified list. The goal is simple: anything that matters should become a clear, structured packet of work that a human or agent can pick up.

One list across everything

If you already use an issue tracker, Worklist doesn't have to replace it. It can run alongside it.

The unified view shows native work units and external issues in one list. Filter by status, size, source, or project. View portfolio-wide across all your projects, or scoped to a single one.

This matters for indie hackers running multiple projects. Instead of checking a handful of separate trackers and repos to see what's active, you check one list. Native items load instantly from the database. External issues stream in alongside them.

Why structured data matters for agents

The conventional issue tracker approach is a title, a free-text description, and maybe some labels. A human reads it, interprets it, asks clarifying questions, and figures out what to do.

An AI agent given that same free-text description will make assumptions. Sometimes good ones, sometimes bad ones. It might change files you didn't want touched. It might solve the wrong problem. It might produce something that technically works but doesn't match what you actually needed.

Structured acceptance criteria and file scope remove the ambiguity. The agent doesn't need to interpret. It has a checklist of what to achieve and a list of where to work. The output is more predictable, more correct, and easier to review.

This is a subtle but important shift. The issue tracker stops being a place to describe problems and starts being a place to specify solutions. The spec is precise enough that an agent can execute it, and the result is verifiable against the acceptance criteria.

Available now

Worklist is live for all Shipchart users. Core work unit creation and management are available now, with the agent-focused workflow built around the same structured data model: delegation, Deep Plan, error-to-task conversion, and integrations all feed into the same list.

If you're already using Shipchart for portfolio management and roadmap planning, Worklist slots in naturally. Your roadmap items break down into work units, those work units can be shaped for coding agents, and the resulting implementation work stays connected to the original task. The full loop from plan to shipped code, in one tool.

Try it at shipchart.app, or read more about Worklist at shipchart.app/platform/worklist.