The Complete ChatGPT Five-Day Work Week System

A practical operating-system guide from The AGI Guide · Updated September 2026

Most productivity systems fail for a boring reason: the plan is static, but your week is not. You wake up late. A meeting moves. A task takes twice as long as expected. You finish something early. A new deadline appears. By Tuesday afternoon, the calendar you carefully built on Sunday is already fiction.

This system uses ChatGPT, Scheduled Tasks, and Google Calendar to make the plan dynamic.

The goal is not to have AI “motivate” you. The goal is to make ChatGPT handle the repetitive planning loop: review what matters, place work into real time, compare plan versus reality, recover unfinished work, and rebuild the schedule when the day changes.

The simple version has five steps:

1. Plan the week before Monday starts.
2. Put the plan on your real calendar.
3. Rebuild the day when reality changes.
4. Track what actually got finished.
5. Carry unfinished work forward automatically.

The advanced version adds a daily operating system, a work-block closeout loop, calendar hygiene, hard-stop rules, a parking lot for new ideas, and optional money/health/context inputs.

The important idea: ChatGPT should not merely make you a to-do list. It should maintain a loop between what you intended to do, what actually happened, and what the next plan should become.

1. What you are building

You are building a small personal operating system with three layers.

Layer 1: Weekly strategy. Once a week, ChatGPT reviews your goals, deadlines, unfinished work, calendar, and current priorities. It decides what the next five workdays should accomplish and places the work into a realistic sequence.

Layer 2: Daily replanning. Each morning, ChatGPT checks the weekly plan against reality. It looks at what changed, what is still unfinished, and what is actually possible today. It then makes a fresh day plan instead of blindly following Sunday’s assumptions.

Layer 3: Closeout and recovery. After work blocks end, ChatGPT checks whether the required output was actually completed. If not, the missing work stays alive and gets placed into a future block instead of quietly disappearing.

The result is a calendar that behaves more like a living system than a static schedule.

You can build only the first layer and already get value. The full loop is what makes it unusually useful.

2. What this system does — and what it does not do

This system can help you:

• turn goals into concrete work blocks;
• schedule those blocks around real commitments;
• reserve meals, exercise, sleep, commute, and transition time;
• recover the day after waking up late;
• shift later blocks when one runs long;
• distinguish “scheduled” from “actually completed”;
• preserve missed work instead of losing it;
• create a parking lot for ideas that should not hijack today;
• use recurring Scheduled Tasks so the planning loop happens automatically;
• make the next plan using evidence from the previous one.

It does not guarantee that you will do the work. It reduces planning overhead and decision friction. You still have to execute.

It also should not be given more permission than it needs. If you only want it to read your calendar and propose blocks, start there. If your account supports calendar write actions and you want ChatGPT to create or update events, review the permissions and approval screens before enabling that behavior.

Feature names and availability can vary by ChatGPT plan, app version, workspace, and region. If a button in this guide is named slightly differently in your account, look for the equivalent Scheduled, Tasks, Apps, or Calendar control.

3. The five-step version

If you only want the version from the video, do this:

Step 1 — Make ChatGPT plan your entire work week.

Create a recurring Sunday task that reviews your goals, unfinished work, deadlines, projects, and upcoming commitments, then builds Monday through Friday.

Step 2 — Connect the plan to your real calendar.

Connect Google Calendar in ChatGPT and tell the planner to inspect existing commitments before scheduling anything new.

Step 3 — Make the schedule adaptive.

When your day changes, tell ChatGPT what changed and ask it to reflow everything that follows while preserving important work.

Step 4 — Track completion.

Create a recurring closeout task that checks whether the output from each work block actually exists.

Step 5 — Carry unfinished work forward.

Tell the system that incomplete outputs must be moved into the next appropriate slot and considered in the next morning’s plan.

That is the core system. The rest of this guide shows how to make each layer reliable.

4. Step 1: create the weekly planner

Open ChatGPT.

Open Scheduled or the Scheduled Tasks area.

Create a new recurring task.

Set it to run once per week, ideally on Sunday evening.

Choose a time when you are usually awake but no longer doing major work. The exact hour matters less than consistency. If Sunday night is unreliable for you, use another recurring time before your work week begins.

The weekly planner should do four jobs in order:

1. gather current context;
2. decide the week’s priorities;
3. translate priorities into concrete outputs;
4. place those outputs into a realistic calendar.

A basic version looks like this:

Every Sunday evening, review my current goals, unfinished work, deadlines, active projects, and upcoming calendar.

Choose the most important outcomes for the next five workdays.

For each weekday:
- choose one main objective;
- define exactly what must exist by the end of the day;
- break the work into realistic blocks with start and end times;
- schedule around existing calendar commitments;
- preserve meals, sleep, exercise, commute, and transition time;
- move lower-priority ideas into a parking lot instead of letting them displace the main objective.

Do not create vague blocks such as “work on project.”
Every work block must end in a specific completed output.

This prompt is intentionally outcome-focused. A calendar full of “work on marketing,” “do startup stuff,” and “study” creates the illusion of structure while leaving the hardest decision unresolved: what exactly counts as done?

5. Define “done” before you schedule time

Every serious work block should have a terminal state.

Bad:

• Work on website
• Content
• Research
• Emails
• Startup

Better:

• Publish one finished Instagram Reel
• Deploy pricing page with mobile verification
• Complete five user interviews and log repeated pain points
• Send follow-ups to every sponsor waiting on a reply
• Produce a working field-test build and record the result

The system gets stronger when the event description includes both the goal and the required output.

Use this rule inside the weekly task:

For every work block, include:
- Goal
- Required completed output
- Why this matters now
- Exact first action
- Dependencies
- Hard stop condition

The “exact first action” is underrated. It removes the first five minutes of wandering around figuring out where to start.

Example:

Goal: publish one revenue-oriented Reel.

Required output: one Reel exported and posted.

First action: open the current script and record the hook.

Dependency: none.

Hard stop: the Reel is published or the block ends, whichever comes first. If unfinished, mark the missing output clearly for recovery.

6. Step 2: connect Google Calendar

Go to ChatGPT settings or the Apps/Plugins area available in your account.

Find Google Calendar.

Connect the Google account that owns the calendar you actually use.

Review the requested permissions.

Then test the connection before trusting it.

Ask:

Read my Google Calendar for tomorrow and list my existing events in chronological order. Do not create or change anything.

Check the result against Google Calendar yourself.

If ChatGPT is reading the wrong calendar, wrong Google account, or wrong timezone, fix that before you automate anything.

Once the connection is correct, add this to your weekly planner:

Before scheduling new work, read my existing Google Calendar.

Treat existing non-planner events as hard commitments unless I explicitly tell you to move them.

Build work around those events instead of assuming my day is empty.

If your connected Calendar permissions support writing events and you want ChatGPT to maintain the actual calendar, add:

Create or update the planner-generated work blocks directly on my Google Calendar.

Do not duplicate existing planner-generated events.

When the plan changes, update the existing planner event rather than stacking a second copy.

7. Use a naming system so ChatGPT knows what it owns

A simple prefix makes calendar maintenance much safer.

For example:

Planner-generated work events must start with [OS].
Routine events generated by the system must start with [ROUTINE].

Never move or delete a calendar event that does not use one of those prefixes unless I explicitly tell you to.

This creates a boundary between:

• things the operating system owns;
• things you added manually;
• meetings or commitments created by other people.

Without a boundary, an aggressive replanning prompt can become ambiguous.

You can use any prefix you want. The value is not the letters. The value is making ownership explicit.

8. Put the full brief inside each calendar event

A title such as “[OS] Content block” is not enough.

The description should carry the execution context so that opening the event tells you exactly what to do.

A strong event description can include:

DAY OBJECTIVE:
Ship one revenue-generating content asset.

BLOCK GOAL:
Publish one Reel.

REQUIRED OUTPUT:
A finished Reel live on Instagram.

WHY NOW:
Content is the current near-term revenue engine.

FIRST ACTION:
Open the script and record the first face shot.

CHATGPT CAN HANDLE:
Script tightening, caption draft, CTA options, fact checking.

I MUST HANDLE:
Filming, performance, final visual judgment, publishing.

DEPENDENCIES:
None.

HARD STOP:
When the Reel is live. If the block ends first, log exactly what remains.

DISTRACTION RULE:
Do not open unrelated social feeds. Put new ideas into the parking lot.

This turns the calendar from a time grid into a set of mini operating briefs.

9. Step 3: make the day adaptive

A static planner assumes Sunday can predict Thursday.

It cannot.

The fix is not to create the perfect weekly schedule. The fix is to make replanning cheap.

When you wake up late:

I woke up at 10:30 instead of 7:00.

Rebuild the rest of today around the new start time.

Do not delete important work.
Preserve hard commitments.
Compress, move, or defer lower-priority blocks first.
Protect a realistic shutdown and sleep time.
Tell me what changed.

When a work block runs long:

This work block ran 45 minutes longer than planned.

Update the calendar to reflect the overrun.

Reflow the remaining blocks in priority order.
Preserve hard commitments.
Do not silently delete unfinished work.
Give me a short summary of what moved.

When you finish early:

I finished this block 35 minutes early.

Use the extra time intelligently.

Pull forward the highest-priority unfinished work that can use this window without disrupting hard commitments.

When an unexpected commitment appears:

A new commitment was added from 3:00–4:00 PM.

Rebuild the rest of the day around it.
Preserve the most important output for today.
Move anything that no longer fits into the next appropriate slot.

The general pattern is:

new constraint → preserve hard constraints → protect priorities → reflow flexible work → keep unfinished work visible.

10. Add a morning operating-system task

The weekly plan is strategy. The morning task is reality.

Create a second recurring Scheduled Task that runs every weekday morning.

Its job is to compare:

• the weekly plan;
• yesterday’s results;
• today’s existing calendar;
• current deadlines;
• newly unfinished work;
• anything material that changed overnight.

A strong version:

Every weekday morning, review my current weekly plan, yesterday’s completed and incomplete work, active projects, deadlines, and today’s Google Calendar.

Choose ONE governing objective for today.

Define exactly what must exist by bedtime for today to count as a win.

Build a realistic minute-level plan around existing commitments.

Every work block must end in a concrete completed output.

Preserve meals, exercise, commute, basic recovery, and a realistic shutdown.

If yesterday left unfinished required work, either place it into today or explicitly defer it to a named future slot.

Put lower-priority new ideas into a parking lot instead of changing the day.

Update planner-owned calendar events without duplicating them.

The morning task prevents a stale weekly plan from becoming a rigid rule.

11. Use one governing objective per day

A long task list is not a priority system.

Ask ChatGPT to choose one sentence that defines the day.

Examples:

• Publish the sponsor deliverable and collect approval.
• Produce a field-test build and run it with three real users.
• Finish the application draft and resolve every missing evidence gap.
• Ship the landing page and send it to ten qualified leads.

Then require a definition of done.

For today, give me:
1. ONE governing objective.
2. ONE definition of done.
3. The work blocks required to make that outcome true.
4. A short parking lot for everything intentionally not being done today.

This is especially useful if you generate ideas quickly. The system acknowledges the ideas without letting them become immediate context switches.

12. Build a parking lot instead of trusting yourself not to pivot

New ideas are not the enemy. Unpriced context switching is.

Add this rule:

When I introduce a new idea during the day, compare it against today’s governing objective.

If it is not more urgent or more important, do not redesign the schedule.

Put it in a PARKING LOT with one sentence explaining why it is deferred.

A useful parking lot is short. It is not another 80-item backlog.

Format:

PARKING LOT
- Idea: [idea]
  Why deferred: [reason]
  Revisit: [specific review point if needed]

The weekly planner can inspect the parking lot later and promote only ideas that still matter.

13. Step 4: track what actually got finished

A calendar event ending does not mean the work was completed.

Create a separate Scheduled Task for work-block closeout.

A practical version:

Check my calendar for planner-generated work blocks that recently ended.

For each ended block, compare:
- the original goal;
- the required output;
- the work I actually completed using available context.

Update the event description with:
- status;
- completed outputs;
- remaining gaps;
- whether the original goal was fully met;
- any satisfaction score I explicitly provided.

Never invent completion.
If evidence is missing, mark the result as unclear or not yet rated.

You can keep the statuses simple:

• Completed
• Missed
• Ongoing / overrun
• Upcoming

If you like visual calendar scanning, assign colors consistently. The exact colors do not matter. Consistency does.

Example:

Use this calendar color system:
- green = completed;
- red = missed;
- yellow = actively ongoing or overrunning;
- blue = upcoming work;
- gray = non-work.

14. Step 5: automatically recover unfinished work

This is the layer that stops the system from becoming a motivational poster.

Add to the closeout logic:

If a required output was not completed, do not treat the calendar block as success.

Record the exact remaining work.

Then place that work into the next appropriate future slot based on priority, dependencies, deadlines, and available time.

Do not silently delete another important block to make room.

If moving the work creates a conflict, surface the conflict and make the smallest reasonable tradeoff.

Also add to the next morning’s task:

Before planning today, inspect incomplete required outputs from prior planner-owned blocks.

For each one:
- finish it today;
- assign it to a named future block;
- or deliberately cancel it with a reason.

Never let unfinished required work disappear without one of those three outcomes.

This is the completion loop:

Plan → execute → inspect → recover → replan.

15. Copy-and-paste task prompts

Here are the three core prompts in one place.

Weekly planner

Every Sunday evening, act as my weekly chief of staff.

Review my current goals, active projects, unfinished commitments, deadlines, promises, upcoming calendar, and anything important that changed this week.

Choose the few outcomes that matter most for the next five workdays.

For every weekday:
- choose ONE governing objective;
- define a concrete definition of done;
- create realistic work blocks with exact start and end times;
- make every work block end in a specific completed output;
- schedule around existing calendar commitments;
- preserve meals, exercise, commute, recovery, and sleep;
- include realistic transitions;
- move lower-priority ideas into a parking lot.

Before adding events, read my Google Calendar.
Treat existing non-planner events as hard commitments unless I explicitly tell you to move them.

Planner-generated work titles must begin with [OS].
Routine blocks may begin with [ROUTINE].
Update existing planner events instead of creating duplicates.

For each work block, include in the description:
- goal;
- required completed output;
- why it matters now;
- exact first action;
- what ChatGPT can handle;
- what I must do manually;
- dependencies;
- hard stop;
- distraction rule.

At the end, give me:
- weekly governing outcome;
- key output for each day;
- what is deliberately being deferred;
- biggest constraint;
- the single scoreboard metric that defines whether the week worked.

Weekday morning planner

Every weekday morning, act as my personal operating guide.

Review:
- the weekly plan;
- yesterday’s completed and incomplete work;
- current projects and deadlines;
- today’s existing Google Calendar;
- any new constraints that materially change the plan.

Choose ONE governing objective for today.

Define exactly what must exist by the end of the day for today to count as a win.

Build a realistic minute-level plan around hard commitments.

Every work block must end in a concrete completed output.
Do not create vague “work on” blocks.

Preserve meals, exercise, commute, basic recovery, transitions, shutdown, and sleep.

If prior required work is unfinished, either:
1. schedule it today;
2. place it into a named future slot; or
3. deliberately cancel it with a reason.

Put new lower-priority ideas in a PARKING LOT instead of changing the day.

Read my calendar before editing it.
Only create or modify planner-owned events.
Update existing [OS] events instead of duplicating them.

Give me one concise morning brief with:
- governing objective;
- definition of done;
- ordered schedule;
- what is deliberately ignored;
- parking lot;
- what must exist by bedtime.

Work-block closeout

Check my Google Calendar for planner-owned [OS] work blocks that recently ended and have not been closed out.

For each block:
1. read the original goal and required output;
2. compare that against the work actually completed using available context;
3. mark the block completed, missed, or ongoing;
4. list completed outputs;
5. list remaining gaps;
6. include my satisfaction score only if I explicitly provided one.

Never invent completion.

If a block is incomplete, record the exact remaining output and move it into the next appropriate future slot.

Do not silently delete other important work.

If the block overran, preserve the actual overrun and intelligently reflow the remaining same-day schedule while protecting hard commitments and planned sleep.

Use this color system consistently:
- green = completed;
- red = missed;
- yellow = ongoing or overrun;
- blue = upcoming;
- gray = non-work.

If nothing needs a closeout, do not notify me.

16. Optional: make the weekly planner use money constraints

If money materially changes what you should work on, give the planner a financial decision rule.

For example:

When cash is tight, prioritize near-term revenue actions before speculative side projects.

Treat uncontracted or unreceived income as $0.

Do not schedule discretionary purchases as assumptions.
Flag any task that requires spending money before placing it on the calendar.

If you use connected financial tools, you can let the planning system reference current balances or recent spending where supported. Keep financial interpretation separate from calendar mechanics. The calendar should use the constraint, not become your accountant.

17. Optional: make the planner respect health and routine

A system that assumes twelve uninterrupted hours of work is usually a bad system.

Tell it what must be protected.

Preserve:
- a realistic wake time;
- morning hygiene;
- meals;
- hydration;
- exercise;
- commute;
- short reset periods;
- evening shutdown;
- enough time in bed for my sleep target.

If work expands, move or compress lower-priority work before deleting basic health or recovery blocks.

If you have a recurring gym routine, include the commute inside the real block instead of pretending teleportation exists.

If lunch usually happens immediately after the gym, encode that as a standing dependency.

The more predictable the routine, the more useful it is to make it explicit once instead of renegotiating it every morning.

18. Optional: add reminders and friction controls

Useful schedule details:

• add a reminder before important planner blocks;
• put your phone in Do Not Disturb during deep work;
• specify which blocks permit inbox checks;
• close unrelated tabs;
• keep one task or document open;
• route random ideas into the parking lot.

Example rule:

During deep-work blocks:
- phone on Do Not Disturb;
- no social feeds unless required by the task;
- no inbox checking unless this is an admin/outreach block;
- keep one primary task open;
- new ideas go into the parking lot.

You are trying to reduce the number of decisions that occur inside the block.

19. How to recover after the entire day collapses

Sometimes a 30-minute reflow is not enough.

Use this reset:

Today is materially off plan.

Do not try to preserve the original schedule.

First identify:
1. hard commitments that still cannot move;
2. the single most important output still worth completing today;
3. anything that can safely move to tomorrow;
4. the latest reasonable shutdown time.

Then rebuild the rest of today from the current time.

Do not punish the missed morning by creating an unrealistic night.

That last sentence matters.

A planning system should optimize the next decision, not create guilt for the previous one.

20. How to handle work that cannot be completed inside one block

Some tasks are bigger than one calendar event.

Split them by observable state changes.

Instead of:

• Build website — 5 hours

Use:

• Finalize page structure — 60 minutes
• Implement hero and primary flow — 90 minutes
• Finish remaining sections — 90 minutes
• Mobile QA and bug fixes — 45 minutes
• Deploy and verify live route — 30 minutes

The closeout system can now tell exactly where the project stopped.

This also makes overruns easier to recover because the unfinished unit is smaller.

21. How to handle dependencies

A task can be important and still be blocked.

Example: a sponsor deliverable depends on script approval.

Do not fill the calendar with blocked production work as if the dependency does not exist.

Add this rule:

Before scheduling a block, check whether its critical dependencies are satisfied.

If a task is blocked by another person, approval, file, payment, access, or decision:
- mark the dependency;
- schedule the smallest useful preparatory work only if it has independent value;
- otherwise use the time for the next highest-priority unblocked output.

This prevents fake productivity around work that cannot actually advance.

22. How to choose priorities without letting novelty win

ChatGPT needs a ranking rule.

A simple hierarchy is:

1. hard deadlines or commitments;
2. tasks that unlock money, users, or another blocked task;
3. core long-term project work;
4. maintenance and admin;
5. interesting but non-urgent ideas.

Your hierarchy may be different. Write it down.

Example:

When two tasks compete for the same time, prioritize in this order:
1. hard external deadlines;
2. near-term revenue or commitments already made;
3. the primary long-term project;
4. necessary admin;
5. optional experiments.

Do not allow a newly mentioned idea to outrank this hierarchy unless new evidence genuinely changes the priorities.

This is how you stop “the thing I just thought of” from becoming the automatic top priority.

23. Make the system learn from estimation errors

The planner becomes much more useful when it notices patterns.

Add to the weekly review:

Review last week for planning errors.

Identify:
- blocks that repeatedly overran;
- blocks I consistently underestimated;
- work I repeatedly postponed;
- times of day when I completed the most important work;
- recurring transitions that were too short;
- recurring commitments the plan forgot.

Use those observations to make next week more realistic.

Do not interpret one unusual day as a permanent pattern.

The goal is not psychological diagnosis. It is better time estimation.

If filming normally takes 45 minutes longer than you expect, the system should eventually stop allocating 30 minutes.

24. The weekly review scoreboard

At the end of the week, measure outputs rather than calendar obedience.

Useful questions:

• What important output shipped?
• What required output was missed?
• Which blocks overran most?
• Which work created revenue, users, learning, or leverage?
• What repeatedly got deferred?
• What should stop appearing on next week’s calendar?
• Which assumption about time was wrong?
• What is the single most important thing to change next week?

A compact review prompt:

Review this week using my calendar and available work context.

Separate:
- completed meaningful outputs;
- missed required outputs;
- overruns;
- repeated postponements;
- planning mistakes;
- useful unexpected work.

Do not score the week by how many calendar boxes were checked.

End with:
1. the most important thing the system got right;
2. the biggest planning error;
3. one adjustment for next week.

25. Common failure: the planner creates a fantasy day

Symptoms:

• no commute;
• no meals;
• no transitions;
• back-to-back deep work for 10 hours;
• zero slack;
• four “top priorities”;
• sleep quietly gets sacrificed.

Fix:

Rebuild this as a schedule a real person can follow.

Include transitions and biological needs.

Limit the day to a small number of meaningful output blocks.

When there is not enough time, explicitly defer work instead of compressing everything unrealistically.

26. Common failure: the planner keeps duplicating events

Fix it with ownership and idempotence.

Before creating a planner event, search the relevant date for an existing [OS] event representing the same work.

If one exists, update it.

Do not create a duplicate.

Preserve non-[OS] events.

If duplicates already exist, clean them up manually once, then make the rule explicit.

27. Common failure: everything becomes “urgent”

If the prompt contains every goal you have ever had, the planner may try to honor all of them every day.

Fix:

Do not schedule every active goal every day.

Choose what matters for this week.

A project may remain active without receiving a block today.

Use the parking lot to preserve awareness without creating calendar clutter.

28. Common failure: unfinished work silently disappears

This is the main reason to use closeouts.

Require one of three outcomes for every missed output:

1. rescheduled;
2. deliberately canceled;
3. waiting on a named dependency.

Nothing else.

29. Common failure: ChatGPT cannot see enough context

Scheduled tasks only know what they can actually access.

Do not assume a task can see:

• local files that were never connected;
• another private account;
• a project file unavailable to Scheduled Tasks;
• a calendar you did not connect;
• a conversation that was deleted;
• information outside the permissions you granted.

If a weekly task keeps making bad plans, first ask whether the necessary source is actually available.

Sometimes the right fix is not a better prompt. It is a better source of truth.

30. Common failure: too many active Scheduled Tasks

Do not create a separate task for every tiny behavior.

Start with:

1. Weekly Planner
2. Weekday Operating System
3. Work Block Closeout

Only add more when the extra task has a distinct job.

Scheduled Task limits vary by plan. If you hit the active-task limit, pause tasks you do not currently need instead of building around a nonexistent slot.

31. Notifications: decide what deserves interruption

Not every task should notify you.

The weekly plan probably should.

The morning plan probably should.

A background closeout task may not need to notify you every time if it can quietly update the system.

Use notifications for:

• decisions;
• major schedule changes;
• blockers;
• missed high-priority outputs;
• things that need your manual action.

Avoid notifications for:

• “everything is normal”;
• routine checks with no change;
• repeated summaries you do not act on.

Your operating system should reduce attention cost, not create a new stream of alerts.

32. Privacy and permissions

Before connecting a work calendar, company account, client information, or sensitive personal data, check:

• which ChatGPT account you are using;
• which workspace you are in;
• what the connected app can read;
• whether it can take actions;
• whether those actions require approval;
• what your employer or organization allows.

Do not put passwords, recovery codes, payment credentials, or unnecessary sensitive information into task instructions.

If you share a Scheduled Task, assume the full task instructions may be visible to the recipient. Keep private context out of the task body.

33. The minimum version to set up today

If the full system feels excessive, start here.

Create one Sunday Scheduled Task:

Every Sunday, review my current goals, deadlines, unfinished work, and Google Calendar.

Build my Monday-Friday work week.

For each day:
- choose one main objective;
- define one concrete definition of done;
- create realistic work blocks around existing commitments;
- preserve meals, exercise, commute, and sleep;
- make every block end in a specific completed output.

Put lower-priority ideas in a parking lot.

Then, whenever reality changes, manually tell ChatGPT:

Here is what changed: [new constraint].

Rebuild the rest of today from the current time.

Preserve hard commitments and the highest-priority output.
Move unfinished work instead of deleting it.

That alone gets you most of the conceptual benefit.

34. The advanced architecture

When you are ready, the complete loop looks like this:

Sunday evening - review the previous week; - inspect goals, deadlines, commitments, and calendar; - choose weekly outcomes; - create planner-owned blocks.

Every weekday morning - inspect yesterday; - recover unfinished required work; - choose one governing objective; - rebuild today against current reality.

During the day - execute the current block; - tell ChatGPT when constraints change; - reflow the schedule instead of abandoning it; - park new ideas.

After blocks - compare required output versus actual output; - mark completion honestly; - preserve overruns; - recover missed work.

End of week - review outputs and estimation errors; - adjust the next plan.

That is the operating system.

35. A final rule: optimize for execution, not calendar beauty

The calendar is not the product.

The completed work is the product.

A beautiful schedule that you ignore is worse than an ugly schedule that keeps adapting to reality.

So judge the system by:

• fewer minutes spent deciding what to do;
• fewer important tasks silently forgotten;
• faster recovery when the day changes;
• more meaningful outputs completed;
• better estimates next week than this week.

The point is not to surrender your judgment to ChatGPT.

The point is to keep your judgment focused on the important decisions while ChatGPT handles the repetitive mechanics of maintaining the plan.

Plan. Execute. Inspect. Recover. Replan.

That loop is the system.