Claude is now my micro-manager

Oz Tamir -

I recently sat down with my manager to lay out the plan for the coming quarter. We framed the conversation around OKRs as a way to get clear on what we actually want to achieve.

For those unfamiliar, OKR (which stands for Objectives and Key Results) is a goal-setting framework popularized by companies like Google.

The idea is simple: you set a few high-level objectives that define what success looks like and then attach measurable key results that tell you whether you’re getting there. It's like a to-do list if your most ambitious self wrote it.

Source: Dmytro Yarmak

I know some people dislike OKRs, but I, for one, love them. They’re a great way to cut through the noise and focus on what matters. They force you to think strategically, pick a direction, and aim for impact - not just activity.

But while OKRs are great at helping you zoom out, they don’t always help when you zoom in. They tell you what to achieve but not how to get there. And if you're anything like me, that’s where things can start to wobble - especially once the quarter is underway and your calendar is full of other people’s priorities.

So I enlisted some help - I asked an LLM to micro-manage me.

The idea? Let the LLM do the planning

Typically, once the OKRs were set, I’d sit down and try to break each Key Result into subtasks, estimate how long things might take, juggle dependencies, and then still get halfway through the quarter and realize I forgot something important.

But this time, I wanted to try something different. Instead of doing all the breakdown and planning manually, I asked an LLM to help.

My thinking was simple: this isn’t a creative task - it’s a reasoning task. It has structure, inputs, and constraints, making it perfect for a model good at structured reasoning.

Building the plan

To get started, I used OpenAI’s reasoning model - O1. The ask was simple: "Turn my OKRs into an actual execution plan: week-by-week, task-by-task."

Because I know that I sometimes struggle with context-switching, I told it to assume a “one day = one task” cadence - no juggling multiple things in a single day. Additionally, I asked it to break down anything too big into smaller chunks. I asked it to consider task dependencies and keep the whole timeline in mind to ensure I hit the goals on time.

This is the prompt I used:

These are my OKRs for the coming quarter.
Today is April 16. The OKR target date is July 31.

Help me plan a week-by-week task list - each task should be something that can be done in a day (if something needs more time, break it down into smaller tasks).

For each task, you should write:
* Title
* Description
* Start date
* DoD (Definition of Done)

Organize the tasks into logical groups - each group should translate into one of the key results. For each group, set a start date and an end date.

Make sure you take into account both the target dates in the OKR and the fact that some of the KRs are dependent on one another.

The result wasn’t magic - but it was good. It was good enough that with just a little bit of back-and-forth, I had something that looked like an actual, trackable plan.

Each KR had a timeline. Each task had a clear outcome. And most importantly, I could look at any given week and know exactly what I needed to do.

Planning done. Now, it was time to get everything up on the board.

Getting the Tasks Into a System

With the plan in place, the next step was getting it into the tools I use.

My task management app of choice is Todoist. Historically, this is the part where I’d either:

  1. Spend an hour manually copying tasks in, or
  2. Spend two hours writing a one-off script to push them in via API.
    (And then not touch it again until next quarter.)

But this is 2025, and we have better tools now - Specifically, MCPs.

There are a few Todoist MCP servers available. I used this one, and installed it via Smithery, which acts as a central repo for MCP servers.

I like Smithery because their CLI makes installing MCPs super easy - all you need to do is run the following command:
npx -y @smithery/cli@latest install @Chrusic/todoist-mcp-server-extended --client claude

Once installed, the only extra thing you’ll need is a Todoist API token:

  1. Log in to your Todoist account
  2. Navigate to Settings → Integrations
  3. Find your API token under Developer
  4. Press Copy API Token

Paste it when prompted, and you're good to go.

Open the Claude app, and behold - it can now access Todoist on your behalf.

Watching the Magic Happen

With the Todoist MCP server up and running and my API token in place, I handed the rest to Claude.

I already used O1 to generate the execution plan earlier in the process. Now, all I had to do was give it a final prompt - this time, with instructions to take that structured task list and push it into Todoist using the MCP interface.

Here’s the prompt I used:

This is my OKR and my task list for hitting the goals in this OKR. I need your help in using your tools to put these tasks into my task-management app (Todoist).

Here's what I need you to do:
* Create Todoist Project called FY26H1 OKR.
* Under this project, create a section for each KR (name it [KR Title] (KR [KR Number])).
* Finally, populate each section with the task from the task list. Put the DoD and the Description together in the task description.

If you are not sure about something, don't assume my intent - ask me how to proceed.

Claude handled the whole thing in one go - no errors, no re-prompts.

It created the projects, slotted each task under the correct KR, and populated the fields precisely as instructed. Start dates, descriptions, labels, priorities - it all showed up as expected in Todoist.

There’s something very satisfying about opening the app and seeing a full quarter of structured, scoped, and scheduled work already laid out - without having to touch an API or spend an afternoon babysitting a migration script.

Conclusion

There’s something very satisfying about opening Todoist and seeing a full quarter of scoped, scheduled work already laid out - without touching an API, writing glue code, or falling into a planning spiral.

But the bigger shift here isn’t just about automation. We’re used to thinking of LLMs as assistants - tools that can help us write code, summarize text, and generate emails. And they’re great at that.

But this flow showed me that models can do more than assist - they can own operational pieces of your workflow. They can reason. Plan. Execute. It will not just help you work faster but also help you work smarter by pushing the low-leverage stuff off your plate entirely.

And that’s the point. I don’t want to spend time manually scoping key results into tickets. I want to focus on the hard parts - the parts that actually require judgment, creativity, and experience. Let the model handle the project management overhead. I’ll show up and do the work.

And the best part? This wasn’t some custom-built workflow with hardcoded paths and brittle dependencies. It’s just a good model, a standard interface, and a few lines of prompt. Which means I can do this again next quarter. And the one after that.