Open Source a Skill: Let AI Take Over the Sticky Note on Your Screen Edge

Last month I built M5 Paper Buddy, connecting an e‑ink screen to Claude Code to monitor what the AI was doing and what needed approval.

I was pretty excited at the time — the physical button for approval added a nice ceremonial feel.

But after a few weeks I realized: it spent more time sitting on my desk than I spent looking at it.

When the AI runs smoothly, there’s no need to monitor it. And when approval is needed, I’m probably already at my computer. It solved an edge case.

The Real Scene Is Hidden Right on the Screen Bezel

Later I noticed a very common phenomenon: many people stick sticky notes on their screen bezels. There are even lots of products selling such notes.

They write what to do today, what time the meeting is, the next step of a project.

Sticky notes exist not because they are great, but because people need a reminder that’s right there when they look up — they don’t want to switch windows or unlock their phone just to check the calendar.

But sticky notes can only hold very limited content, and once written they stay static.

The schedule changes, the sticky note doesn’t. The task is done, the sticky note still sits there. It’s an object frozen in time.

Now, we have AI at hand. It has Memory, Agents, can read my calendar, check my GitHub, chat with me.

If we let AI decide what should stick on the screen bezel, when to tear it off, and when to replace it — that’s a whole different thing.

That’s exactly what AI Desk Card Skill aims to do.

Physically it’s a 4.7‑inch e‑ink screen with magnetic attachment (similar to MagSafe), directly attachable next to your monitor.

Behind it is a Skill — plug it into an AI Agent like Claude Code or Codex, and the AI takes over everything:

decides what to push, when to push it, and what to display when the screen is off.

Github: https://github.com/op7418/ai-desk-card

Let me explain clearly how it works in practice and what problems it solves.

Use Case 1: Schedule and Todos Update Themselves

I set the top‑left slot to calendar and the middle slot to todos.

When I sit at my desk in the morning, the screen already shows the complete arrangement for the day: morning meetings, afternoon workout, evening deadline for a draft.

This data comes from Feishu Calendar, read directly by the AI Agent via the Feishu CLI.

In the afternoon I booked a coffee with a friend on Thursday.

I told the AI, “Add a coffee on Thursday afternoon at 3 PM.” The AI both wrote the event into Feishu Calendar and refreshed the card on the screen.

The new item appeared in the todo slot.

Even better is reverse sync. After I finished the first draft of AIGC Weekly, I said to the AI, “The weekly is done.” The corresponding line on the screen was crossed out.

Sticky notes can’t do this. They can only capture a snapshot of one moment, but the essence of a schedule is a constantly changing stream of states.

When the display device is connected to your Memory, it directly shows the current state of you and your context.

Use Case 2: When Idle, It Becomes Your Business Card

This is my favorite feature after building it.

E‑ink has a physical property: it retains the image after power is off.

I specifically added a “Quiet Hours” mode for this — after 11 PM, or when you long‑press the “Sleep” button, the screen automatically switches to a digital business card and enters deep sleep.

The card shows your avatar, introduction, and QR code. The whole screen is crisp black‑and‑white, with that unique paper‑like feel of e‑ink.

From that moment on, the screen consumes zero power, but the image stays.

It’s magnetic, so you can detach it from the monitor, slip it into your bag — it’s very lightweight.

Next time you have dinner with new friends, pull it out and hand it over: black‑and‑white business card + QR code. Add the contact, then put it back in your pocket.

The whole process: no plugging in, no booting up, no awkward fumbling for a QR code in an app.

And when you sit at your desk in the morning, the AI wakes it up and automatically switches back to work mode — schedule, todos, PR queue are back.

Most of the limitations of e‑ink (no backlight, slow refresh, retains image after power‑off) are disadvantages in many scenarios. But if you don’t fight these limitations and instead design with them, you’ll find things that regular screens can’t do.

Use Case 3: I No Longer Miss GitHub Activity

I maintain open‑source projects like CodePilot. The biggest burden is invisibility — I don’t know if there are new PRs or Issues without opening GitHub.

But opening GitHub every ten minutes is terrible for work rhythm; it fragments your attention.

Now the bottom slot of the AI Desk Card permanently shows a pr-queue widget.

Whenever there’s a new PR in the CodePilot repo, someone @mentions me in an Issue, or the CI fails, the AI pushes it up.

The numbers are small and unobtrusive, but a quick glance tells me if there’s something to handle. When I finish the current piece of work, I’ll go check them all at once.

Even more advanced: the AI knows what I’m doing.

When I’m deeply focused on writing AIGC Weekly, it automatically demotes the PR queue and pushes things up only when an Issue with a critical label appears.

When I switch to working on CodePilot, the PR queue returns to the main slot.

What to show on screen is essentially a scheduling problem, not a configuration problem.

Traditional dashboards let you configure widgets. It works for the first week, but after that it becomes a wall nobody looks at.

AI makes proactive decisions because it knows what you’re doing and it can swap things.

Use Case 4: Weather, Breaks — All the “Should Have But Never Remember to Configure” Things

The widget type that surprised me most is break-reminder.

I often sit for three or four hours without moving.

This widget, after a period with no button activity, gently pushes a line in one of the slots: “Time to get up and walk around.”

The e‑ink screen doesn’t glow, doesn’t pop up a window, doesn’t beep, doesn’t vibrate. But when you look up and see a line of text, you naturally pause.

Its biggest difference from a Pomodoro timer: no coercion. It just exists, without interrupting you.

If you’re in the flow of coding or writing, you’ll ignore that line.

If you’re already tired and your mind is wandering, seeing that line will actually make you get up for a glass of water.

Weather is the same.

I don’t specifically check whether it will rain today, but after the top widget quietly shows “Rain this afternoon,” I’ll grab an umbrella before going downstairs.

This kind of “low‑priority but useful” information used to rely solely on you remembering to check it. Now it sits at the edge of your vision, waiting to be noticed when you need it.

How to Set It Up: Fully Guided by AI

The entire installation process has no app, no Bluetooth pairing page, no phone QR code scanning. You just tell the AI:

“Help me install ai-desk-card: https://github.com/op7418/ai-desk-card”

Then these things happen:

• AI detects whether you have PlatformIO installed; if not, it installs it automatically
• Detects whether you have connected USB; if not, it prompts you to do so
• Automatically compiles the firmware and flashes it to the M5Paper (about 1 minute)
• Asks for your Wi‑Fi password and writes it into the device
• Asks “Which cards do you want to see and how often should they refresh?”
• Pushes the first widget

During the whole process you only need to answer two questions: Wi‑Fi password and what you want to see.

After that, setting up scheduled tasks is just one sentence: “Let the card refresh weather and unread emails every 30 minutes, weekdays 8 AM to 10 PM.”

The AI writes the cron job, registers the loop, and manages the scheduling itself.

When the scheduled task runs, the AI reads your Memory to decide what content to push.

For example, I told it to update every morning at 9 AM. It checks the Memory for my recently active projects (CodePilot, AIGC Weekly, etc.) and arranges the slots by importance.

There is no “settings page designed by an app engineer” here — because the AI is the settings page.

What used to require ten clicks to configure now takes one sentence.

A Design Opposite to Traditional Hardware: Widgets Pre‑built, AI Only Fills Data

I need to explain the implementation philosophy separately, because this is the biggest difference between AI Desk Card and traditional IoT devices.

Usually when you build a smart device, widgets are hard‑coded into the firmware:

Clock style, weather icons, font sizes — all decided by the firmware engineer before shipping. To add a new feature, you need a new firmware / OTA / re‑certification. That’s why 99% of smart devices look exactly the same three months after purchase as they did out of the box.

AI Desk Card goes the opposite direction: 16 widget templates are pre‑built on the server side; the AI Agent only needs to stuff JSON data into them.

For example, the visual layout of the pr-queue widget (a header area, four PR rows, each with a status icon) is written on the rendering side.

The AI doesn’t need to draw, layout, or choose font sizes. It just sends a request like this to the daemon:

{
  "slot": "bottom",
  "widget": "pr-queue",
  "data": {
    "items": [
      { "repo": "op7418/codepilot", "title": "Fix #123", "status": "open" },
      { "repo": "op7418/codepilot", "title": "New feature: dark mode", "status": "pending" }
    ]
  }
}

The server uses Python + Pillow to render this JSON into a 540×280 pixel image and pushes it to the e‑ink screen.

This idea actually comes from the generative UI we built for the CodePilot desktop app.

There we went to the opposite extreme: the model generates HTML/SVG in real time and renders it as an interactive widget.

The two directions look completely different, but the spirit is the same — UI is decided by AI, not configured by the user.

Why go the opposite way for e‑ink? Because constraints are different.

A browser can run arbitrary code, has a powerful font engine, and can load from a CDN. So letting AI generate UI is fine.

E‑ink rendering is constrained: a full‑screen GC16 refresh takes 2 seconds, a Chinese font set weighs several megabytes, pixel accuracy can’t be wrong. AI generating UI directly would be too heavy.

So we reversed it: UI is prepared in advance, and the AI only decides what to fill, which slot to place it in, and when to swap.

This component library keeps growing. The hardware itself stays basically the same, but its capabilities keep growing.

Final Thoughts: AI Agents Liberate Hardware from Built‑in Features

Let’s talk about something bigger.

The moat of traditional hardware companies is “what my device can do.”

CPU, sensors, operating system, built‑in apps — these define the capability ceiling. Once manufactured and shipped, the capability is essentially locked.

With the AI Desk Card approach, the source of hardware capability is replaced.

It’s just an e‑ink screen + ESP32. What it can do depends entirely on what information the AI Agent can access.

Calendar from Feishu CLI, PRs from GitHub CLI, weather from any API, Memory from your Obsidian vault — all these data sources live on the Agent side, not in the hardware.

When the AI Agent becomes the information hub, hardware can be thin and purpose‑built.

It doesn’t need to have a hundred built‑in features. It only needs to do one thing well — display content when the AI decides to push it.

The cost of this is also very low. The M5Paper V1.1 costs about 600 RMB. Similar open‑source development boards will become even cheaper, maybe 300–400 RMB. E‑ink, color e‑ink, small TFT screens, even Kindle or e‑ink readers — theoretically they can all be adapted to the same Skill.

Next I plan to do a few more things:

• Support M5Paper S3 and other e‑ink dev boards like Inkplate / Waveshare
• Try writing an adapter layer for old Kindles, turning idle readers into desktop companion screens
• Integrate with Home Assistant to push smart home status onto the desk card — living room temperature, door lock status, robot vacuum location
• Explore the possibilities of color e‑ink, opening up more widget types

Every additional piece of hardware supported is one more way AI can reach the physical world. These devices don’t need to become smarter — they are just physical output ports for the AI Agent.

The one that’s really getting smarter is the AI on your desk. And its pace of getting smarter is much faster than hardware iteration.

GitHub: https://github.com/op7418/ai-desk-card

If you found this content helpful, please give it a like or share it with someone who needs it.