TL;DR: DevFocus is a free, open-source focus timer and day plan for Cursor and VS Code, built for engineers working with AI. A deliberately small plan for today (3 to 5 tasks), real breaks, and a day summary that proves you actually worked, because in the agent era that's weirdly easy to doubt. Get it on Open VSX (Cursor) · VS Code Marketplace · GitHub
A couple of years ago I built a focus timer as a JetBrains plugin. The idea was simple: I didn't want my phone anywhere near my workflow, so the timer had to live where the work happened, inside the IDE. It worked. A few hundred developers picked it up, a surprising number of them in Germany, and I kept shipping updates.
Then I switched to Cursor, started working with AI agents daily, and slowly noticed my own tool solving a problem I no longer had.
We don't really "write code" anymore, and it messes with your head
Think about how we worked just a couple of years ago. You opened VS Code, Xcode, or Android Studio and you typed. The work was the code, and the code came out of your fingers. That's what my timer was built to protect: long stretches of hands-on-keyboard work.
Now? I open Cursor and an agent does most of the typing. Cursor's own, Claude, whichever. My day is prompting, scoping a feature end to end, reviewing diffs, deciding what's in and what's out, thinking about the product. The keyboard work shrank. The judgment work grew.
Here's the part nobody warns you about: this messes with your sense of having done anything.
You ship more than you ever did before the AI era. Genuinely more. But at 7pm, some part of your brain goes: "the code was written by AI... did I actually do enough today?" So you stay. You fire one more prompt. You review one more diff. You spend enormous hours in front of the screen, achieving more than ever, while quietly feeling like you're achieving less. The old proof of work, the lines you personally typed, is gone. Nothing replaced it.
The old risk was losing focus. The new risk is never disengaging. Partly because agents erased the natural seams of the day (a long compile, a commit, "I'll stop after this function"), and partly because of that nagging feeling that you haven't earned the right to stop.
When an agent does the typing, your actual job splits into two things:
- Knowing what to work on next.
- Knowing when to stop.
Every focus tool I could find addressed neither. So I rebuilt DevFocus from scratch for Cursor and VS Code, one half for each job.
Job one: a day plan that lives where you work
This one started as a purely personal itch.
Every morning I'd open my notes app and write down today's tasks on one sheet. But that same notes app held a dozen other sheets I used constantly, so by mid-morning the todo sheet was buried three pages deep, and by afternoon I'd forgotten it existed. I kept losing the thread of my own day inside my own system.
The fix was obvious in hindsight: the plan has to live where the work happens. For me, that's Cursor. No switching to a notes app, no other window. The plan sits in the sidebar of the editor I'm already staring at.
And it's deliberately constrained:
- 3 to 5 tasks for today, maximum. DevFocus won't let you write an endless list. An infinite todo list is just anxiety with checkboxes.
- Everything else goes to "Later." A stray thought mid-session ("oh, I should fix that flaky test") gets captured with Alt+Shift+A (⌥⇧A on Mac) from anywhere and lands in a Later tray you triage the next morning, instead of hijacking today.
- One task at a time. When a focus session starts, only the active task matters. It becomes your intent, shown in the status bar, and completed sessions count against it automatically. Check it off mid-session without stopping the timer and the next open task steps in.
- Priorities shift, so the plan bends. Reorder and rename in place: hover, click, done. No dialogs.
Job two: knowing when to stop
This is the half most focus tools get wrong, because they assume the work itself will tell you when to rest. It used to. It doesn't anymore.
So DevFocus paces the day deliberately:
- Real breaks, with real suggestions. When a break starts, you get a rotating, screen-appropriate nudge (stretch, water, look away) instead of a bare countdown. You can skip, but the cost of skipping is visible, not hidden. A tool that silently lets you skip every break is just decoration.
- A daily goal. Set a target number of sessions. The status bar and panel show where you stand, so "one more session" is a decision, not a compulsion.
- Wind-down. Set an evening hour. After it, DevFocus stops offering another session and nudges you to wrap up with a day summary instead: sessions done, tasks done, focus time. Not a guess, not a vibe. Here's what you actually did today. A defensible end to the day, which agents will otherwise never give you.
- A weekly rhythm strip. Seven days of your focus history and the week's total, kept locally for 30 days. When your brain says "the AI did everything, you did nothing," the strip says: you did four hours of deliberate, focused work today and eighteen this week. Close the laptop.
That last point deserves its own words, because it answers the 7pm guilt directly. The invisible work of the agent era (prompting, reviewing, deciding) becomes visible as focused time you can point at. Receipts, basically.
The features I built and then deleted
Two of them, actually. I think what you remove says more about a tool than what you add.
Streaks. Every productivity app has them, so I assumed DevFocus should too. I built the whole thing: the counter, the chain, the "don't break it" pressure. Then I used it for a week and tore it out. A streak is a loss-aversion mechanic. It punishes rest, which is exactly backwards for a tool whose entire reason to exist is pacing yourself through a day that no longer has natural stopping points. If your focus tool makes you feel guilty for taking Sunday off, it's not a focus tool. It's a slot machine. That's why the rhythm strip is a fact, not a chain to maintain.
Agent-aware breaks. I built a "Waiting on AI" mode: press a key when you send a prompt, and the session freezes into an open-ended rest until you're back. Clever on paper. Then I asked myself one honest question: will anyone really press a button 50 times a day, once per prompt? No. And there was a deeper problem. Pausing the clock while the agent runs treats that time as "not work," when supervising an agent (holding context, reviewing, deciding what's next) is precisely the work now. The feature quietly agreed with the guilt this tool exists to fight. So it went. Your focus time includes your agent time, because you are working.
Both decisions are written down in the repo's design docs, not just implemented. I'd rather show the reasoning than claim good taste.
The boring-but-important stuff
- Three rhythms: Classic (25/5), Deep Work (50/10), or fully Custom. Pick what fits, no methodology attached.
- A circular dial with session segments, so you can see round progress at a glance.
- Status bar always shows time, phase, and current task.
- A sound cue and a desktop notification at the three moments that matter: when a session ends, when a break ends, and when a round completes. Toggle either independently. The copy stays calm and single-line, because you're mid-thought and a notification shouldn't shout.
- Persistent state: survives editor restarts, restored as paused, never silently loses your time.
- Fully local: no accounts, no telemetry, no gamification, nothing leaves your machine.
- The UX reasoning lives in the repo (docs/UX_PLAN.md, UX_DESIGN.md, UI_SPEC.md).
Install
- Cursor: Extensions panel, search DevFocus (installs via Open VSX)
- VS Code: same search, or the VS Code Marketplace
MIT licensed, source on GitHub:
DevFocus
A focus timer and day plan for engineers working with AI. Sessions, real breaks, and a defensible end to the day — for the prompt → wait → review loop not the old 9-to-5.
| Today's plan | Focus | Break |
|---|---|---|
 |
 |
 |
Contents
- Why
- Screenshots
- Features
- Getting Started
- Keyboard Shortcuts
- Modes
- Settings
- Design Principles
- Cursor IDE
- License
Why
AI coding agents changed the shape of the work: it's no longer 25 minutes of typing, it's prompt, wait, review, repeat. The old risk was losing focus. The new one is never disengaging — agents remove the natural stopping points, so nothing tells you when to rest or when the day is done. DevFocus is the pacing layer for that loop: a plan for today, protected focus time, real breaks, and a defensible end to the day.
Screenshots
| First run — pick your rhythm | A clean start |
|---|---|
 |
 |
| Break time | Wind-down — a good stopping point |
|---|
If an agent is doing half your typing and you've caught yourself at 7pm wondering whether you did enough today, try DevFocus. It's free, 800+ engineers are already using it, and it keeps the receipts.
How do you deal with this? Do you track your days differently now that an agent does the typing, or have you stopped tracking altogether? Genuinely curious what's working for others.
Top comments (0)