Your Project Manager Can't Keep Up
We spent forty years teaching humans to feed project management tools. The next tools will feed themselves. The bet behind Merrily and Syncopate is that AI-native tooling — designed for machine interoperability, not human data entry — eliminates the 60% overhead tax and frees builders to just build.
By Michael Craig
The Unexamined Assumption
Every productivity tool you’ve ever used — Franklin Planner, Palm Pilot, Basecamp, Jira, Linear — solved the same problem: helping humans organize, track, and perform work. Every generation improved the interface, the speed, the collaboration model. None of them questioned the core assumption.
The human is the operator.
Every status update, every ticket drag, every standup summary, every hill chart nudge — a person translating reality into the tool’s language. You do the work, then you tell the tool you did the work. Two jobs, one paycheck.
AI broke that assumption. Models can read code, parse conversations, observe commits, understand intent, and take action across systems. But look at what the industry is building: copilots that help you update your Jira board faster. AI that drafts your status report. Bots that auto-triage your inbox.
They’re making humans faster at feeding the machine. Nobody’s asking whether the machine should feed itself.
Forty Years of the Same Bet
The tools changed. The bet didn’t.
Paper era (1980s–2000s). Franklin Planner, GTD. Methodology-first, tool-agnostic. The individual is the unit of productivity. FranklinCovey sold 10,000 Palm Pilots per week bridging paper to digital — new medium, same mental model. David Allen’s Getting Things Done spawned hundreds of digital implementations, every one of them assuming a human doing the capturing, clarifying, organizing, reflecting, and engaging. Five verbs. All human.
Web era (2004–2018). Basecamp, Jira, Asana, Trello. The unit shifted from “my task” to “our project.” Transparency and visibility became features. Dashboards appeared. Reporting appeared. But every status change still required a human click. Jon Evans wrote in TechCrunch that Jira had become “an antipattern” — the map mistaken for the territory. He was right, and the problem wasn’t Jira specifically. It was the assumption that territory needs a human cartographer updating the map in real time.
Speed era (2019–2024). Linear, Notion, ClickUp. Linear’s thesis: strong tool opinions reduce overhead. Keyboard-first, opinionated workflows, less ceremony. Notion went the opposite direction — infinite flexibility, databases as building blocks. Both rejected Jira’s middle ground of configurable complexity. Both still assumed a human operator. Just a faster one.
AI-assistant era (2025–now). Notion AI agents that work autonomously for twenty minutes. Linear’s “Agentic Backlog” that auto-creates tickets from Slack conversations. Monday.com’s agent builder. Asana Intelligence. Gartner predicts 40% of enterprise apps will feature task-specific AI agents by end of 2026, up from less than 5% in 2025. Linear’s CEO declared “issue tracking is dead” and reports coding agents installed in 75% of enterprise workspaces.
And yet. The underlying data model still assumes a human operator. AI summarizes your board. Drafts your update. Triages your inbox. The tool’s API, permissions, and workflow are designed for human hands with AI gloves on.
The Overhead Tax
This isn’t a minor UX complaint. The numbers are brutal.
Asana’s own Anatomy of Work Index — 10,000+ knowledge workers surveyed — found that 60% of work time is “work about work.” Not the skilled work people were hired to do. Communicating about work. Searching for information. Switching between apps. Managing shifting priorities. Getting and giving status updates.
Over a year, the average knowledge worker spends 103 hours in unnecessary meetings, 209 hours on duplicative work, and 352 hours talking about work rather than doing it. Half of project professionals spend a full day or more each month manually collating project status information.
Developers on Glassdoor report spending more time explaining Jira tickets than writing code. Research from UC Irvine found it takes 23 minutes and 15 seconds to regain focus after an interruption — and every ticket notification, every “can you update the board?” message, every standup where you narrate what you did yesterday is an interruption.
The overhead tax isn’t a bug in any one tool. It’s structural. Every tool that assumes “human updates the system” creates a tax proportional to the system’s complexity. More projects, more scopes, more team members — more tax. The tool that was supposed to help you manage complexity becomes the primary source of complexity you’re managing.
The AI-Assistant Trap
The obvious response — bolt AI onto existing tools to reduce the tax — is a trap. It’s the right instinct with the wrong execution.
When Notion ships AI agents that autonomously work for twenty minutes across hundreds of pages, it’s impressive. When Linear monitors Slack and email to auto-create tickets, assign engineers, and estimate effort, it’s genuinely useful. When Monday.com builds infrastructure for AI agents to “sign up, authenticate, and operate directly within the platform,” it’s ambitious.
But all of these are retrofits. The data model was designed for human operators. The permission model assumes human judgment at every decision point. The workflow engine expects human-initiated state transitions. Layering AI on top of that model creates AI that mimics human operation — clicking the buttons faster, filling the forms more accurately, attending the standups virtually.
That’s not a paradigm shift. It’s a faster hamster wheel.
The paradigm shift is asking: what if the tool was designed from the ground up for machine interoperability? What if the data model, the API, the state machine, the permissions — all of it — assumed that AI would be the primary operator for routine coordination, and humans would intervene only for judgment calls?
What AI-Native Actually Means
AI-native tooling isn’t “tool + chatbot.” It’s a different architecture.
Structured state over freeform fields. A hill position of 0–100 with semantic meaning at each range (0–50 = figuring it out, 50 = figured out, 50–100 = making it happen) is machine-legible. A Jira ticket with a freeform description, seventeen custom fields, and a status that means different things in different workflows is not.
Observable progress over reported progress. An AI can infer scope progress from code commits, test results, PR reviews, and deployment logs. It cannot meaningfully infer progress from a human forgetting to drag a card from “In Progress” to “Done.”
Hierarchical data with clear semantics over flat ticket lists. A workspace → cycle → bet → scope → task hierarchy where each level has a defined relationship to the others is navigable by machines. A flat backlog of 3,000 tickets with labels and epics and components and versions is navigable by nobody.
API-first, UI-second. The API is the primary interface. The web UI is one client among many — useful for human shaping and review, but not the bottleneck through which all state changes must flow.
Shape Up Saw It First
Ryan Singer’s Shape Up methodology — born at Basecamp in 2019 from seventeen years of practice — accidentally built the mental model that AI-native tooling needs.
No backlog. Shape Up cleans the slate every cycle. Only a handful of shaped pitches compete for the next build period. If an idea is important enough, it comes back. This isn’t just process hygiene — it eliminates the infinite Jira graveyard that AI would either hallucinate priorities from or waste cycles triaging.
Fixed time, variable scope. The appetite is set by humans. How work fills that appetite is discovered during building. This maps directly to Ethan Mollick’s framework for AI delegation: clear objectives, authority limits, success criteria, required outputs. Mollick argues that management skills — not technical AI expertise — are the critical capability for working with agents. Shape Up’s shaping process is that management skill, formalized.
Hill charts over tickets. Progress is a confidence curve, not a task completion percentage. Going uphill means discovering unknowns. Going downhill means executing against understood work. An AI can update hill position by observing code velocity, test coverage trends, and PR review patterns. It cannot meaningfully auto-close Jira tickets, because ticket closure is a human judgment about human intent.
Scopes, not tasks. Scopes are discovered during building. They represent meaningful vertical slices of the work — things a user would recognize, not implementation details. Tasks are daily, disposable, personal. This hierarchy maps perfectly to AI delegation: AI tracks scope-level progress; humans manage their own moment-to-moment task lists. Nobody reports tasks upward. Nobody maintains a task board for stakeholder theater.
Singer himself is now prototyping AI-assisted shaping with Claude Code — having it slice shaped projects into vertical slices and implement them sequentially. The methodology is staying the same. The execution partner is changing.
The Merrily / Syncopate Bet
Merrily and Syncopate are two sides of this bet.
Merrily is the team view: betting tables, cycles, pitches, hill charts. The tool stakeholders use to decide what to build and track whether it’s working. Syncopate is the individual view: daily scopes, lightweight tasks, hill position updates. The tool builders use to stay oriented moment to moment.
The shared language between them is the hill chart. And the bet is about who — or what — maintains that shared language.
| Layer | Human does | AI does |
|---|---|---|
| Shaping | Defines the problem, sets appetite, draws boundaries | Analyzes pitches for risk, suggests scope breakdowns |
| Betting | Decides what to build this cycle | Surfaces signals from feedback, financials, usage data |
| Building | Writes code, makes design decisions, moves the hill | Tracks scope progress from commits and tests, predicts trajectories, flags stalls |
| Reporting | Reviews hill charts periodically | Generates status, syncs between tools, triggers circuit-breakers |
The key design decision: humans do two things. Shape work periodically — what to bet on, what appetite to set, which pitches are ready. And execute moment to moment — write the code, make the design call, decide “I’ve figured this out” and push past the hilltop. Everything between those two activities — the status tracking, the progress reporting, the scope documentation, the stakeholder updates — is coordination work. And coordination work is exactly what AI does well when the data model is designed for it.
This isn’t theoretical. Merrily’s financial module already demonstrates the pattern. AI-powered transaction classification using Claude processes hundreds of transactions with detailed reasoning, achieving meaningful auto-approval rates. The human reviews edge cases and makes judgment calls. The AI does the structured, repetitive, pattern-matching work. Same model, applied to project coordination instead of accounting.
The Willison Warning
Simon Willison’s “lethal trifecta” framework is the responsible counterweight to all of this enthusiasm. Any agent with access to private data, exposure to untrusted content, and ability to externally communicate is a security risk. He documented a real-world GitHub MCP exploit proving the point — one MCP server that mixed all three patterns became an exfiltration channel.
Willison is deeply skeptical of guardrails as solutions. Companies claiming “95% attack capture rates” miss the point: in security, 95% effectiveness is catastrophic failure. His alternative: constrain agent capabilities from the outset. Once an LLM agent has ingested untrusted input, it must be constrained so that it is impossible for that input to trigger consequential actions.
This is where MCG’s privacy-first architecture becomes load-bearing, not just principled. Zero-knowledge design isn’t only an ethics play — it’s a prerequisite for safe AI operation. If your tool lets AI agents operate autonomously, you need architectural constraints on what they can access and what actions they can take. You can’t exfiltrate data you never had access to. You can’t corrupt a system that doesn’t trust inputs by default.
The first-party data architecture we’ve been building wasn’t designed for AI-native tooling. But it turns out that the same constraints that protect user privacy — local-first storage, end-to-end encryption, zero-knowledge server design — also naturally limit the blast radius of any compromised agent. Privacy architecture and AI safety architecture are, it turns out, the same architecture.
The Punchline
The best project management tool is the one you never have to open.
Not because it doesn’t exist. Because it’s doing the coordination work in the background — observing your commits, tracking your progress, updating your hill charts, generating your status reports, flagging when a scope is stalling — while you focus on the only two things humans are actually good at: deciding what matters and doing the work.
We spent forty years building increasingly sophisticated systems for humans to tell computers what they’re doing. The next generation of tools will watch what you’re doing and tell the stakeholders for you.
That’s the bet. Merrily for the stakeholders who need to see the hills. Syncopate for the builders who need to climb them. AI for everything in between.
The overhead tax is 60% of your working life. We’d like it back.