I let Claude change my desktop wallpaper and now I never miss a deadline (prompt included)

At some point, all productivity systems hit the same wall: They only work if you remember to check. Notion It doesn’t yell at you, Asana doesn’t follow you, and your calendar reminders are easy to ignore.

But what if all your tasks were displayed right on your desktop? That would ensure that they are always in sight and on your mind. So I’ve let Claude manage and update my wallpaper based on my to-dos, and my deadline blind spots have basically disappeared.

How does Claude change my wallpaper?

You didn’t know Claude could do this, did you?

When I talk about this workflow, the part that surprises people the most is that Claude can change my wallpaper. Now, this isn’t some fancy “computer usage” scenario where Claude moves the mouse, right-clicks on an image, and selects “Set as desktop background.” It’s much more elegant than that.

Windows has a built-in system. API called System parameter information which allows any program to set the desktop background by pointing to an image file. So, all Claude has to do is write and run a small script that calls this API with the path to an image, and Windows instantly applies it as your new wallpaper, without the need for third-party apps or special software.

How does Claude add tasks to my wallpaper?

Yes, Claude can also edit images.

Now that you understand how Claude updates your desktop wallpaper, the next question is: how do you add tasks to it? By default, Claude cannot generate or edit images like ChatGPT does—Does not include a built-in image model. So how do I update the image with my task list?

The answer is code.

there is a Piton library called Pillow that allows you to manipulate images programmatically. You can open an image, draw text on it, add shapes, overlay transparent layers, and save the result as a new file.

Claude writes and runs a Python script that takes a base wallpaper, draws a semi-transparent card in the center, and places task names, due dates, and a short quote inside. Everything is made up on a single floor. JPEG so that Windows can use it directly as wallpaper.

How does Claude know my assignments?

This part is actually the simplest.

In the most basic version of this workflow, you can tell Claude about your tasks in a chat and he will update your wallpaper accordingly. But you can make this process more automated and hands-free.

The easiest way is to connect Claude directly wherever you manage your tasks. For me, that’s Notion. Claude has a native connector for Notion: you plug it in once and can read your task database directly, including task names, due dates, and statuses in real time.

Claude also supports native connectors for Asana and ClickUp if you use them instead. If your tool is not in the default connector market, you can configure a custom MCP connector using their API. It takes a little more setup, but you can ask Claude to code the implementation for you.

Once the integration is implemented, you don’t need to remember your tasks and manually talk to Claude. You can check the app, read your tasks and generate the wallpaper automatically.

How do I run this system on autopilot?

It’s of no use to me if hands-free doesn’t work.

By now you should have a clear idea of ​​how the process works, but I want it completely automated. I want to wake up in the morning, open my computer, and see my desktop updated with my tasks and the right mood for the day.

To make that happen, I built a three-layer system.

It starts with a scheduled task that calls Claude every six hours. Claude looks up my current tasks in Notion and decides the mood for the day: calm, motivated, or urgent. It then selects an image from a specific folder that matches that mood, records my tasks to it, and saves it locally.

The second layer is a PowerShell script that uses Windows’ built-in FileSystemWatcher to monitor the wallpaper file. As soon as Claude writes a new image, the script activates and calls the Windows API to apply it. The update happens almost instantly.

The third layer is Windows Task Scheduler to start the observer script silently on each login. This way, even after rebooting, everything resumes automatically.

The result is a desktop that updates every six hours on my deadlines. If I’m on the right track, I see a calm wallpaper. If things are coming due soon, switch to a more motivational tone. And if something goes past its due date, I get an urgent red card staring at me every time I minimize a window.

Get this system for you

The first thing you need is Claude Coworkavailable in the Claude desktop app; this automation will not work in the web application. The desktop app is available on Windows and macOS.

Next, you’ll need a Notion account or any app where you manage your tasks.

Once everything is set up, paste the following message into a new Claude Cowork session. Claude will explain how the system works and then ask you a few quick questions: your screen resolution, where your tasks are located, whether you want to use your own wallpapers or have Claude source them for you, and how often the wallpaper needs to be updated.

From there, it builds the entire system in a single session: the Python script, the PowerShell observer, and the Task Scheduler configuration.

Here is the message:

# Dynamic Wallpaper Setup Prompt
---

You are setting up a **Dynamic Desktop Wallpaper System** for the user. This system automatically updates their Windows desktop wallpaper every few hours based on their real tasks from Notion — showing what's due, how urgent things are, and a contextual motivational quote. The wallpaper changes mood (calm / motivated / urgent) based on their task state.

Before doing anything, introduce yourself and explain the system clearly:

---

**What this system does:**
- Reads the user's tasks from Notion automatically
- Determines a "mood" based on urgency (calm = all good, motivated = things due soon, urgent = overdue tasks)
- Picks a matching wallpaper photo for that mood
- Composites a clean overlay card showing their tasks + a mood-matched quote
- Saves the result and applies it to their Windows desktop instantly
- Repeats automatically every few hours with no user action needed

**What it looks like:** A beautiful full-screen photo wallpaper with a centered dark card overlay showing tasks, due dates, and a short punchy quote — all styled to match the urgency of their day.

---

Then ask the user the following questions **before doing any work**. Wait for their answers before proceeding:

1. **Screen resolution** — What is your monitor resolution? (e.g. 1920x1080, 2560x1080 ultrawide, 2560x1440, 4K)
2. **Notion** — Do you have a Notion account and the Notion MCP connected to your Claude session? (If not, pause and help them set it up first)
3. **Task page** — Where are your tasks in Notion? (Share the page URL or name — Claude will help locate them)
4. **Wallpaper style** — Do you want to use pre-made wallpapers downloaded from GitHub, or do you have your own wallpapers you'd like to use?
5. **Moods** — The default setup uses three moods: calm, motivated, urgent. Are you happy with these or do you want to rename/adjust them?
6. **Refresh frequency** — How often should the wallpaper auto-update? (Every 2 hours / 4 hours / 6 hours — default is 6)

---

Once you have their answers, proceed with setup in this exact order. **Explain each step as you go** — what you're doing and why — so the user understands the system they're building.

---

## STEP 1 — Create the Wallpaper folder

Create a `Wallpapers` folder in their chosen workspace directory. All files for this system live here.

---

## STEP 2 — Set up wallpaper images

**If the user has their own wallpapers:**
Ask them to copy their images into the Wallpapers folder. Then ask them to assign each image to a mood — calm, motivated, or urgent — ideally 2-3 images per mood for variety. Rename them to the naming convention: `calm_01.jpg`, `calm_02.jpg`, `motivated_01.jpg` etc. If they're unsure which mood to assign an image to, look at the image and suggest based on the visual tone (peaceful/serene = calm, energetic/dramatic = motivated, dark/intense = urgent).

**If the user wants pre-made wallpapers from GitHub:**
Download 9 images from the `dharmx/walls` GitHub repository — 3 per mood. Use git sparse/blobless clone to avoid downloading the entire repo:

```bash
git clone --filter=blob:none --sparse https://github.com/dharmx/walls.git /tmp/walls_repo
cd /tmp/walls_repo
git sparse-checkout set .
```

Then use `git cat-file blob ` to download individual files by their blob SHA. Choose:
- **calm** — peaceful nature scenes (lakes, waterfalls, mountains, icebergs)
- **motivated** — dramatic landscapes (canyons, city at night, aerial views)
- **urgent** — dark/intense imagery (fires, dark alleys, dramatic skies)

Save as: `calm_01.jpg`, `calm_02.jpg`, `calm_03.jpg`, `motivated_01.jpg` ... `urgent_03.jpg`

**In both cases:** resize/crop images to match the user's screen resolution before saving. The engine expects all wallpapers to match the target resolution exactly.

---

## STEP 3 — Create wallpaper_metadata.json

Create this file in the Wallpapers folder mapping each wallpaper to its mood and text color:

```json
{
  "wallpapers": (
    {"file": "calm_01.jpg", "mood": "calm", "text_color": "#ffffff"},
    {"file": "calm_02.jpg", "mood": "calm", "text_color": "#ffffff"},
    {"file": "calm_03.jpg", "mood": "calm", "text_color": "#ffffff"},
    {"file": "motivated_01.jpg", "mood": "motivated", "text_color": "#ffffff"},
    {"file": "motivated_02.jpg", "mood": "motivated", "text_color": "#ffffff"},
    {"file": "motivated_03.jpg", "mood": "motivated", "text_color": "#ffffff"},
    {"file": "urgent_01.jpg", "mood": "urgent", "text_color": "#ffffff"},
    {"file": "urgent_02.jpg", "mood": "urgent", "text_color": "#ffffff"},
    {"file": "urgent_03.jpg", "mood": "urgent", "text_color": "#ffffff"}
  )
}
```

---

## STEP 4 — Create quotes.json

Create a curated set of mood-matched quotes. These are used contextually — calm quotes are grounding, motivated quotes energize, urgent quotes push the user to act immediately.

```json
{
  "calm": (
    "One thing at a time. Done well.",
    "Clarity comes from action, not thought.",
    "Slow is smooth. Smooth is fast.",
    "Focus on what's in front of you.",
    "A calm mind gets more done.",
    "Do the work. Let the rest follow.",
    "Progress, not perfection.",
    "Start where you are. Use what you have.",
    "The secret is just to begin.",
    "Breathe. Then do the next right thing."
  ),
  "motivated": (
    "You've got this. Now prove it.",
    "Energy follows intention. Set yours now.",
    "Ship something today. Anything.",
    "Done beats perfect every single time.",
    "The gap between where you are and where you want to be is called work.",
    "Push through. Future you will thank you.",
    "Today's effort is tomorrow's result.",
    "Stop planning. Start executing.",
    "Your to-do list won't clear itself.",
    "Make today count. It won't come back."
  ),
  "urgent": (
    "You're behind. Stop reading this and move.",
    "There's no later. There's only now.",
    "The clock is running. Are you?",
    "Deadlines don't negotiate. You need to.",
    "Every hour you wait makes it harder.",
    "This is the moment. Not the next one.",
    "Urgency is not panic — it's clarity. Act.",
    "The work won't do itself. Get on it.",
    "Nothing clears a deadline like starting.",
    "You know what needs to happen. Do it."
  )
}
```

---

## STEP 5 — Create wallpaper_engine.py

This is the rendering engine. It reads `wallpaper_config.json`, picks a wallpaper and quote for the mood, composites a centered rounded card with tasks and quote, and saves `current_wallpaper.jpg`.

Key design principles:
- **Centered dark card** with rounded corners (radius 18)
- **Full padding** on all sides (44px minimum) — nothing touches the border
- **Center-aligned text** throughout
- **Three distinct visual styles** per mood:
  - Calm: cool blue-dark panel, ice-blue accent bar, blue-tinted dividers
  - Motivated: warm brown-black panel, amber accent bar, warm border glow
  - Urgent: red-tinted dark panel, thick red accent, red border outline
- **Dynamic height** — card grows with number of tasks, always perfectly centered on screen
- **Two-pass layout** — compute exact height first, then draw, so bottom padding always matches top
- **Overdue tasks** highlighted in red/orange
- **Done tasks** shown in green

Use Python Pillow for image compositing. Install with: `pip install pillow`

The card layout (top to bottom):
1. Accent bar (mood color, 4-6px, rounded top)
2. Header text ("Today's Focus" / "Let's get it done" / "Action Required")
3. Thin divider line
4. Tasks (name bold + due date below each)
5. Thin divider line
6. Quote in quotation marks
7. "Updated HH:MM" timestamp

---

## STEP 6 — Create the Windows wallpaper watcher

Create two PowerShell scripts:

**watch_wallpaper.ps1** — A FileSystemWatcher that monitors `current_wallpaper.jpg` and instantly applies it to the Windows desktop whenever Claude updates it. Uses `SystemParametersInfo` Windows API. Runs silently in the background.

**setup_wallpaper_watcher.ps1** — Run once as Administrator. Registers `watch_wallpaper.ps1` as a Windows Task Scheduler task that starts at logon, so the watcher survives reboots.

After creating both scripts, instruct the user to:
1. Right-click `setup_wallpaper_watcher.ps1` → Run as Administrator
2. Confirm the task registered successfully with: `Get-ScheduledTask -TaskName "ClaudeWallpaperWatcher"`

---

## STEP 7 — Fetch Notion tasks and generate first wallpaper

Using the Notion MCP, fetch the user's tasks. For each task extract:
- Task name
- Due date (formatted as YYYY-MM-DD)
- Status (Done / In Progress / Not Started / etc.)
- Priority if available (High / Medium / Low)
- Whether it's overdue (due date is before today)

Determine mood:
- **urgent** — any task is overdue
- **motivated** — tasks due within 2 days
- **calm** — everything else

Write `wallpaper_config.json`:
```json
{
  "mood": "calm",
  "tasks": (
    {"name": "Task name", "due": "2026-05-05", "status": "Pending", "priority": "High", "overdue": false}
  ),
  "quote": "placeholder",
  "generated_at": "2026-05-02 15:30"
}
```

Then run: `python3 wallpaper_engine.py`

The wallpaper will be generated and — if the watcher is running — applied to the desktop immediately.

---

## STEP 8 — Verify everything works

Ask the user to confirm:
1. The wallpaper changed on their desktop
2. The card is centered, readable, and has proper padding
3. Their actual tasks appear correctly

If anything looks off, troubleshoot before moving on.

---

## STEP 9 — Explain ongoing usage

Tell the user:

**Manual refresh:** Just tell Claude "refresh my wallpaper" or "new wallpaper" at any time. Claude will fetch current Notion tasks and regenerate.

**Automatic refresh:** To set this up, create a Cowork scheduled task that runs every few hours, fetches Notion tasks, determines mood, and regenerates the wallpaper automatically — no user action needed.

**The watcher:** As long as the `ClaudeWallpaperWatcher` task is in Task Scheduler (set it up once, it runs at every logon), any wallpaper Claude generates will appear on the desktop within 1 second.

**Customising quotes:** Edit `quotes.json` directly to add your own quotes per mood.

**Customising wallpapers:** Drop new images into the Wallpapers folder and add entries to `wallpaper_metadata.json`.

---

## Important notes for Claude

- Always use `# -*- coding: utf-8 -*-` at the top of Python files. Avoid em dashes and special Unicode characters in Python/PowerShell scripts — they cause encoding errors.
- The Pillow library is required: `pip install pillow --break-system-packages` (Linux sandbox) or `pip install pillow` (Windows).
- When writing large Python files, write them via bash `cat >` heredoc rather than the Write tool to avoid file truncation issues.
- The wallpaper engine uses a two-pass layout system: simulate the card height first, then draw. This ensures the bottom padding always matches the top.
- Test all three moods visually before calling setup complete.
- If the user's Notion tasks have a different structure than expected, adapt the field mapping accordingly.