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

At some point, every productivity system runs into the same wall—it only works if you remember to check it. Notion doesn’t yell at you, Asana doesn’t follow you around, and your calendar reminders are easy to dismiss.

But what if all your tasks were displayed right on your desktop? That would ensure they’re always in sight—and on your mind. So I’ve been letting Claude manage and update my wallpaper based on my pending tasks, and my deadline blind spots are basically gone.

How does Claude change my wallpaper

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

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

Windows has a built-in system API called SystemParametersInfo that lets any program set the desktop wallpaper 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 applies it instantly as your new wallpaper—no third-party apps or special software required.

How does Claude add tasks to my wallpaper

Yes, Claude can edit images as well

Now that you understand how Claude updates your desktop wallpaper, the next question is: how does it add tasks to it? By default, Claude can’t generate or edit images the way ChatGPT can—it doesn’t include a built-in image model. So how is it updating the image with my task list?

The answer is code.

There’s a Python library called Pillow that lets you manipulate images programmatically. You can open an image, draw text on it, add shapes, layer transparent overlays, 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 your task names, due dates, and a short quote inside it. Everything is composited into a single flat JPEG so Windows can directly use it as a wallpaper.

How does Claude know my tasks

This part is actually the simplest part

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

The easiest way is to connect Claude directly to wherever you manage your tasks. For me, that’s Notion. Claude has a native connector for Notion—you connect it once, and it 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 those instead. If your tool isn’t in the default connector marketplace, you can set up a custom MCP connector using its API. It takes a bit more setup, but you can ask Claude to vibe-code the implementation for you.

Once the integration is in place, you don’t have to recall your tasks and manually talk with Claude. It can query the app, read your tasks, and generate the wallpaper automatically.

How I run this system on autopilot

It’s useless to me if it doesn’t work hands-free

By now, you should have a clear idea of how the process works, but I want it fully 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 fetches my current tasks from Notion and decides on a mood for the day—calm, motivated, or urgent. It then picks an image from a specified folder that matches that mood, etches my tasks onto 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 triggers and calls the Windows API to apply it. The update happens almost instantly.

The third layer is the Windows Task Scheduler to start the watcher script silently at every logon. This way, even after a restart, everything resumes automatically.

The result is a desktop that updates every six hours based on my deadlines. If I’m on track, I see a calm wallpaper. If things are due soon, it shifts to a more motivating tone. And if something slips past its due date, I get a red, urgent card staring back at me every time I minimize a window.

Get this system for yourself

The first thing you need is Claude Cowork, available in the Claude desktop app—this automation won’t work in the web app. 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 prompt below into a new Claude Cowork session. Claude will walk you through how the system works, then ask a few quick questions—your screen resolution, where your tasks live, whether you want to use your own wallpapers or have Claude source them, and how often the wallpaper should refresh.

From there, it builds the entire system in one session: the Python script, the PowerShell watcher, and the Task Scheduler setup.

Here’s the prompt:

# 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.