How I Turned My Performance Review Into a Fully Automated Daily Actionable System (With AI help)

Performance reviews are good at telling you where you fell short. They are terrible at telling you what to do about it tomorrow morning.

After six months at my current company, I received mine. Three reviewers, three perspectives, one dense block of feedback. The content was fair (for the most part), but now i had to get to work, but how? There were no clear next steps on how to move forward, no way to know if I was moving in the right direction between now and the next cycle. Just a document.

The automation engineer in me had an idea, one that would take the ambiguity, friction of execution, execution paralysis out of the way so that I only focus on the actual work needed doing to improve. I wanted to turn that document into a system, one that runs quietly in the background, nudges me daily, and tracks progress without me having to think about it. Here’s exactly how I built that, using AI (Claude + ChatGPT), a few shell scripts, Apple Reminders, and a cron job, all running on my laptop (Macbook).

The Problem with Feedback Loops

Most performance feedback lands in one of two places: a forgotten folder, or a vague mental note. Neither produces change, at least to me.

One of the biggest issues is the gap between receiving feedback and operationalising it. The feedback tells you what to improve. It rarely tells you how to do that in the next 24 hours. Bridging that gap manually, writing action items, scheduling check-ins, remembering to actually do things is friction. And guess what kills follow-through, friction.

The goal of this setup is to eliminate that friction entirely. Once built, the system handles the mundane job of reminding you of the when, the what and the how and all you do is just show up and just do the work. Which is where the actual value lies anyway.

The Architecture Before the Code

Before writing a single line, I mapped out the three things the system needed to do:

1. Generate the plan: 90 days of daily tasks derived from my performance review, one task per working day, 12 weeks × 5 days = 60 tasks.
2. Deliver the plan weekly: Each Sunday, populate my per-day Reminders lists (Monday through Friday) with the upcoming week’s tasks.
3. Mark the week done: Each Friday, automatically complete all that week’s tasks so the master list stays clean.

I deliberately constrained the toolset: iPhone, MacBook, Apple Reminders. No paid software, no new SaaS subscriptions. The Apple ecosystem handles sync natively, once a reminder exists on the Mac, it appears on my iPhone without any extra work.

Step 1: Use AI to Derive Actionable Tasks from Your Review

The performance review gave me themes, not tasks. Feedback like “david could take more ownership” or “needs to improve cross-team visibility” is directionally useful but not executable.

I shared the review with ChatGPT, which had months of professional context about my work, and asked it to be honest: what are the actual gaps, and what would closing them look like day-to-day?

Then I moved to Claude and asked it to design a 90-day attack plan. The constraint I gave it was important: each action item had to be small enough to do in under an hour, on a normal workday, without requiring special setup. The output was 60 tasks organized into 12 weeks, each week building on the last.

The trade-off here is specificity. The more context you give the AI tool of choice about your actual role and team setup, the more useful the tasks output will be. Generic prompts produce generic plans. I gave it my job title, team structure, current projects, and the verbatim feedback. That specificity made the difference.

It’s also worth noting that I removed any personally identifiable information (PII) for everyone except myself from the review text file and team structure. After all, the focus is on my performance, not theirs. However, since their roles were relevant to the review, I replaced their names with aliases such as “teammate A” and “manager B.”

The tasks looked like this:

Week 1: Decide and document flagship ownership area (Proactivity & Ownership)
Week 1: Write 1-page proposal draft (Proactivity & Ownership)
Week 2: Raise one risk early in planning (Early Risk Signaling)
Week 7: Draft mini reliability proposal (Technical Initiative)
...

Each task maps to a theme, which maps back to a specific piece of feedback. That traceability matters at the next review, I can point to concrete evidence of what I did to address each point.

Step 2: Seed the Master Reminders List with the growth plan

With 60 tasks in hand, the next step was getting them into Apple Reminders, all of them, with the correct due dates, automatically.

The choice to use Apple reminders was simple; it is a reminders app, it sits natively on my macbook and iphone, I always have my iphone with me during the work day and guess where i do my work during the work day? The macbook.

The script takes a START_DATE variable and calculates each task's due date using macOS BSD date with epoch arithmetic. Each task gets seeded into a list called "90 Day Growth Plan" with a 9am due time.

#!/bin/bash
LIST_NAME="90 Day Growth Plan"
START_DATE="2026-02-23"
add_task() {
    TITLE="$1"
    YEAR="$2"
    MONTH="$3"
    DAY="$4"
    /usr/bin/osascript <<EOF
tell application "Reminders"
    tell list "$LIST_NAME"
        set dueDate to current date
        set year of dueDate to $YEAR
        set month of dueDate to $MONTH
        set day of dueDate to $DAY
        set hours of dueDate to 9
        set minutes of dueDate to 0
        set seconds of dueDate to 0
        make new reminder with properties {name:"$TITLE", due date:dueDate}
    end tell
end tell
EOF
}

Run it once. The master list is populated. You don’t touch it again.

Step 3: Weekly Sync

The master list is the source of truth, but it’s not what I look at daily. Looking at all 60 tasks at once is exactly the kind of cognitive overload I am trying to avoid.

Every Sunday at 8pm, a cron job runs a shell scriptweekly_growth_sync.sh. It calculates the upcoming Monday, loops through each weekday, queries the master list for tasks due on that date, and writes them into per-day lists (Monday, Tuesday, etc.). Below is just a snippet of the script.

#!/bin/bash

set dayReminders to reminders of sourceList whose due date ≥ targetDate and due date < nextDate
repeat with r in dayReminders
    set reminderName to name of r
    set existing to reminders of targetList whose name is reminderName
    if (count of existing) is 0 then
        make new reminder at targetList with properties {name:reminderName}
    end if
end repeat

The duplicate check matters. If the script runs more than once in a week, say you run it manually to debug, you don’t want Monday’s list to have the same task twice. The count of existing guard handles this cleanly.

The trade-off with per-day lists is maintenance: if you add a task or shift a date in the master list, the weekly lists don’t automatically update. They pull a fresh snapshot every Sunday. This is intentional as it keeps the weekly view stable once the week has started.

Step 4: Auto-Complete the Week

By Friday, the week’s tasks should be done. Whether they are or not, I want the master list to reflect a completed week so it stays clean and readable.

Every Friday at 6pm, a second cron job runs the shell script weekly_growth_complete.sh. It calculates the Monday-to-Friday window for the current week in the master list and marks every task in that range as done. Below is a snippet.

#!/bin/bash#!/bin/bash

set weekReminders to reminders of sourceList whose completed is false ¬
    and due date ≥ thisMonday and due date < endOfFriday
repeat with r in weekReminders
    set completed of r to true
end repeat

This is a deliberate design choice, not a bug. The script completes tasks regardless of whether you actually did them. The reasoning being that if you didn’t do something and it wasn’t deferred, the week is over. Leaving it open creates visual debt that discourages you from opening the list at all. Done is a better default than an ever-growing backlog of guilt.

If you want stricter tracking, you can invert the logic, instead of marking incomplete tasks done, you could log them elsewhere before completing them.

Step 5: Schedule It and Forget It

The cron entries are straightforward:

# Every Sunday at 8pm populate next week's daily lists
0 20 * * 0 /path/to/weekly_growth_sync.sh

# Every Friday at 6pm complete the current week
0 18 * * 5 /path/to/weekly_growth_complete.sh

One important caveat: cron does not run missed jobs. If your macbook is closed at 8pm Sunday, the sync doesn’t run. You’ll open Monday with empty daily lists.

The fix is migrating to launchd. A launchd plist agent with StartCalendarInterval will fire the job when the machine wakes, even if it missed the scheduled time. For a home Mac mini running 24/7, cron is fine. For a laptop, launchd is the right call.

What This Actually Looks Like Day-to-Day

I followed Chris Asante in this video here to set up my reminders app and its widgets strategically to remove another layer of friction, remembering to open the reminders app to tick off items and to give me a glimpse into my day’s tasks.

With how the reminders widgets are set up following the above video, each morning I have the day’s reminders lists at a glance with little to no effort. Each list has a task that has a due date and time for that day at 9am (start of the work day), I do the work, add a note about what I actually did, and check it off.

That’s the entire interaction. The system handles everything else.

By week 9, the tasks look like this:

Week 9: Ask manager what next-level ownership means (Strategic Alignment)
Week 9: Lead milestone discussion (Visible Leadership)
Week 9: Mentor peer on technical topic (Leverage & Enablement)
Week 9: Publish cumulative impact summary (Promotion Narrative)

At this point, the themes from the original performance review are showing up as concrete evidence and not just intentions.

What This System Is and Isn’t

This is a delivery mechanism, not a productivity philosophy. It doesn’t make you work easier. It simply removes the decision fatigue around what to work on, which makes it easier to start.

The tools are deliberately boring. Bash, AppleScript, cron, Reminders. That’s the point. Boring tools seldom break, don’t require subscriptions, and don’t need maintenance. The Apple ecosystem sync means anything created on the Mac appears on my iPhone automatically. Zero configuration, zero friction.

This is version 1.0 of the system and it shows, there’s no handling for PTO, sick days, or paused weeks. If you miss a week, the Friday auto-complete will mark those tasks done regardless.

A future improvement would be addressing the above as I recently went on vacation aka PTO and my iPhone, on one serene morning reminded me to “study the system and identify a potential improvement path”

The bigger point is this: you don’t need better tools. You just need to use the tools you already have more deliberately. This whole setup took an evening to design and build and has run without intervention for weeks. The next performance review will be different, not because I worked harder, but because I actually showed up every day, lazy but building value.

All scripts referenced in this article are available in this GitHub repo.

Conclusion

I’m running this with Apple ecosystem native tools because that’s what I have. But this idea doesn’t belong to any ecosystem.

If you’re on Android and/or Windows, you can wire this up with Google Tasks, Gemini, and a Python script running on a schedule. If you’re already using Notion, connect it to n8n or Zapier and have your tasks pushed there automatically. If you have a Raspberry Pi sitting on your desk doing nothing, yes, you can run the automation from there as well.

The principle is the same everywhere: AI breaks down the goal into digestible chunks (with your guidance), automation delivers it to you daily, and YOU just show up.

90 days later, you’re an improved champ

The tools are just one path. Find yours; whether that’s for school, a side project, or a business goal and build something lazy that delivers value every day. If you want a thought partner while you figure it out, don’t be shy. Reach out and we’ll build these lazy systems together.

Credits

Two people deserve a mention here because they shaped how I think about automation and productivity.

Chris Asante showed me how Apple Reminders can be a serious productivity layer, not just a grocery list app. You can find the specific video here

**Stephen Robles **got me deep into Apple Shortcuts in a way that changed how I approach automation day to day.

Neither of them told me to build exactly this. I just took what they planted and grew something that fit my life to solve a problem I had.

That’s kind of the whole point.