DEV Community: Johannes Millan

Why Multitasking With AI Coding Agents Breaks Down (And How I Fixed It)

Johannes Millan — Sat, 21 Feb 2026 20:02:43 +0000

AI coding agents are starting to feel like teammates.

You ask one to refactor a module.

Another to write tests.

A third to prototype a feature.

Individually, they’re powerful.

But the moment you try to run them in parallel, things get messy.

This article is about why that happens — and what I learned trying to fix it.

The Multitasking Problem

Running one AI coding session is simple.

Running three at the same time usually looks like this:

Three terminal windows
Multiple feature branches
Manual context switching
No clear overview of what each agent is doing

Technically, it works.

Cognitively, it doesn’t scale.

The friction appears in small ways:

You forget which terminal is working on which branch.
You accidentally reuse context.
You lose track of long-running operations.
You hesitate to spin up “just one more” agent because overhead increases.

The CLI gives you power — but no structure.

Why `tmux` (Alone) Isn’t Enough

You can improve layout with tools like tmux.

That helps visually.

But it doesn’t solve workflow structure:

You still manually create branches.
You still manage isolation.
You still need to remember which session owns which task.
You still lack higher-level organization.

Layout is not workflow.

And when working with AI agents, workflow matters more than layout.

The Key Insight

The breakthrough for me was this:

Each AI session should behave like an isolated feature branch — automatically.

Not just another terminal pane.

A structured environment.

If AI agents are “teammates,” then each one deserves:

Its own workspace
Its own git worktree
Clear visual boundaries
Easy creation and disposal

That reduces cognitive load dramatically.

Designing for Parallel AI Work

I started experimenting with a simple idea:

What if running multiple AI coding agents felt more like managing multiple feature branches in a visual workspace?

Instead of:


Terminal A
Terminal B
Terminal C

You get:

Agent Session 1 → Feature branch + isolated worktree
Agent Session 2 → Separate branch + separate worktree
Agent Session 3 → Experimental sandbox

All visible at once.

All running natively.

No API wrappers.

No abstraction layers limiting features.

What I Built

To explore this idea, I built Parallel Code, a desktop app that:

Runs Claude Code, Codex, and Gemini CLI directly
Creates git worktrees automatically per session
Tiles multiple agent sessions in a structured UI
Keeps full CLI behavior intact

It doesn’t change how the agents work.

It just makes multitasking practical.

Repository:

https://github.com/johannesjo/parallel-code

(Insert GIF demo here)

What Changed in My Workflow

After switching to structured parallel sessions:

I hesitate less before spawning a new agent.
Experimental work feels safer.
Long-running refactors no longer block other tasks.
Context switching feels deliberate instead of chaotic.

The biggest difference isn’t speed.

It’s clarity.

The Bigger Question

Right now, most AI-assisted development assumes:

One agent. One terminal. One task.

But that might not reflect how we’ll work long-term.

If AI agents become real collaborators, we’ll need better ways to:

Run them in parallel
Isolate work safely
Maintain visibility across sessions
Reduce mental overhead

We may be in the “single-agent IDE” phase of a multi-agent future.

I’m Curious

If you’re using AI coding agents heavily:

Do you run multiple sessions in parallel?
How do you manage isolation?
Is terminal + tmux good enough?
Where does your workflow break down?

I’m still iterating on this idea, and I’d appreciate thoughtful feedback.

7 Small Workflow Tweaks That Actually Helped My Developer Productivity

Johannes Millan — Mon, 12 Jan 2026 13:34:15 +0000

I've tried every productivity system. GTD, Pomodoro, bullet journals, countless apps. Most didn't stick.

I've been building developer tools for 8 years, which means I've had plenty of time to experiment with what works.

What actually helped were small, boring changes. Nothing revolutionary - just friction reduction.

1. Time-boxing instead of todo lists

Todo lists are infinite. Time-boxes aren't.

Instead of "finish auth feature," I block 2 hours for it. When time's up, I stop or consciously decide to continue. This killed my tendency to rabbit-hole.

I use a time-boxing app for this - it combines todos with time-blocking, so I'm not switching between apps.

2. One tab for the current task

Not "minimal tabs." One tab. For whatever I'm working on right now.

Everything else goes into a bookmark or gets closed. When I notice 15 tabs open, that's a signal I've lost focus.

3. Write tomorrow's tasks today

Takes a few minutes at end of day. Saves the "what should I work on?" decision fatigue the next morning.

The key: be specific. Not "work on API" but "add validation to /users endpoint."

4. Pull tasks from your issue tracker automatically

I used to manually copy Jira tickets into my task manager. Now they sync automatically.

Most dev-focused tools support this (GitHub Issues, GitLab, Jira, etc.). Set it up once, never copy-paste again.

5. Track time, but not for productivity theater

I don't track time to prove I'm working. I track it to see where time actually goes.

It's easy to feel busy without knowing where the hours went. Tracking gives you data to spot patterns you'd otherwise miss.

6. Scheduled break reminders

I ignored break reminders for years. Then I started getting wrist pain.

Now I have a reminder that actually interrupts me. I stand up, look away from the screen. It's annoying and it works.

7. Daily review, weekly review

Daily: What did I finish? What's carrying over?
Weekly: What patterns am I seeing? What's consistently not getting done?

The weekly review is where you catch systemic problems, not just task problems.

None of this is groundbreaking. That's the point. Small changes, consistently applied, compound.

Full disclosure: I actually built a tool that implements most of these ideas - Super Productivity. Free, open source, no account needed. But these tips work with any setup.

What small workflow changes have worked for you?

Wrote a new article!

Johannes Millan — Wed, 07 Jan 2026 19:12:34 +0000

What to Do While Waiting for AI Code Assistants

Johannes Millan ・ Jan 7

#productivity #ai #programming #focus

What to Do While Waiting for AI Code Assistants

Johannes Millan — Wed, 07 Jan 2026 19:01:43 +0000

AI coding assistants create a strange new rhythm in development work. You prompt, then wait. Thirty seconds. Two minutes. Sometimes ten. The tool does work so you don't have to – but what do you do with yourself in the meantime?

Most developers fall into one of two traps. Some context-switch: check Slack, open Twitter, skim an email. By the time Claude finishes, they've loaded entirely new mental context and lost the thread of what they were building. Others stare at the spinner anxiously, refreshing their focus on the pending output, getting no recovery at all.

Both approaches waste what could be valuable time. Research on diffuse thinking shows the brain continues processing problems during unfocused periods (Baird et al., 2012). These micro-waits are built-in recovery that most developers never had before AI tools. The key is knowing how to use them.

This guide covers research-backed techniques for making AI wait times productive without breaking your flow state. Whether you're using Claude Code, GitHub Copilot, Cursor, or ChatGPT for coding, the same principles apply.

The Uncertain Wait Problem

AI tool waits differ from builds or test runs in one crucial way: you don't know how long they'll take. A simple refactor might finish in 30 seconds. A complex multi-file edit could run for five minutes. An agent task exploring your codebase might take 20 minutes or more.

This unpredictability matters. Research on the psychology of waiting shows that uncertain waits feel significantly longer than known waits (Maister, 1985). When you watch a progress bar, you can plan. When you watch a spinner with no ETA, anxiety creeps in.

That anxiety triggers the impulse to "just quickly check" something else. But attention residue research demonstrates that even brief task-switches carry real costs. Gloria Mark's research on workplace interruptions found workers often need over 20 minutes to fully return to an interrupted task (Mark et al., 2005). Self-interruption – choosing to switch – has similar effects.

The solution isn't to sit frozen, nor to dive into something else. It's to choose activities that:

Don't load new context into working memory
Provide genuine micro-recovery
Can be dropped instantly without loss

Match your activity to the uncertainty, not the actual wait length. If you don't know whether it's 30 seconds or 5 minutes, don't start anything you'd regret abandoning.

Physical Resets: Drop-Instantly Activities

The simplest wait-time activities are physical. They require no mental context, provide genuine recovery, and you can stop mid-stretch when the output appears.

The 20-20-20 rule: A commonly recommended guideline – every 20 minutes, look at something 20 feet away for 20 seconds. AI waits are perfect triggers. Screen work causes eye strain through sustained near-focus; looking at distant objects lets your eye muscles relax.

Posture check: Roll shoulders back. Unclench your jaw. Most developers accumulate tension without noticing. Five seconds of awareness helps.

Stand and stretch: Hip flexors shorten from sitting. A quick standing stretch takes 30 seconds and requires no commitment. You're not "doing yoga"–you're just not sitting for a moment.

Hydration: Grab water. Even mild dehydration impairs cognitive performance and mood (Ganio et al., 2011). The wait is a natural reminder.

Three deep breaths: Slow breathing activates the parasympathetic nervous system, shifting from stress response to rest-and-digest mode. Fifteen seconds, zero context required.

Research on microbreaks supports this approach. Henning et al. found that brief, frequent breaks can improve comfort and productivity, particularly when combined with light stretching (Henning et al., 1997). AI waits provide natural microbreak triggers throughout your day.

Context-Preserving Mental Tasks

Some activities keep you mentally adjacent to your work without loading new context. These work well for medium waits – one to five minutes – where physical resets feel too brief.

Re-read your prompt: What did you ask Claude to do? Re-reading primes you to evaluate the output critically when it arrives. You're not starting new work; you're preparing to receive completed work.

Scan surrounding code: Stay in the same file or module. Glance at the functions above and below where you're working. This refreshes context without introducing new mental models.

Draft your next instruction: Think ahead to what you'll ask next. You can write it out or just formulate it mentally. This is dropable anytime – when output arrives, you evaluate that first.

Review your own recent changes: Scroll through your git diff or recent edits. Catch issues while the logic is still fresh. This uses the same mental context as your current task.

Mental walkthrough: Trace the expected behavior in your head. If Claude is refactoring a function, think through what the result should look like. This keeps you engaged without external input.

Sketch test scenarios: You don't need to write actual test code – just jot down what you'd want to verify. "Should handle empty input." "Should fail gracefully if API is down." "Edge case: user has no permissions." AI tools are good at turning plain-language test descriptions into actual tests, so your notes become immediately actionable when the output arrives.

The key insight comes from working memory research. Cowan's work shows we hold roughly four items in working memory at once (Cowan, 2010). Activities that use the same slots as your current task don't compete with it. Activities that load different context create interference. Reviewing your own prompt uses the same context. Reading a Slack thread loads something entirely new.

Anti-pattern: "Reviewing someone else's PR" sounds productive but loads entirely different codebase context. Save code review for dedicated blocks, not AI waits.

Diffuse Thinking: Let Your Brain Work

Sometimes the best activity is no activity. Your brain continues processing problems even when you're not consciously working on them.

Baird et al. demonstrated this in a 2012 study on incubation. Participants working on creative problems who took breaks with undemanding tasks showed substantial improvement compared to those who kept working or did nothing. The key qualifier: undemanding. Scrolling social media doesn't count – it demands attention without providing recovery.

Techniques that enable diffuse thinking:

Window gazing: Look outside. Let your eyes relax on distant objects. Your mind will wander back to the problem without forcing it.

Walk to the kitchen: Get coffee or water. Don't check your phone. The physical movement plus environmental change gives your default mode network room to work.

Doodle or fidget: Mindless hand movement occupies the part of your brain that would otherwise generate anxiety about waiting. Works well for longer waits.

Close your eyes briefly: Thirty to sixty seconds of nothing. Not meditation – just temporary disengagement. Particularly helpful when you're mentally fatigued.

Sanity-check your assumptions: Ask yourself: What assumption am I making that could be wrong? What would a simpler version of this look like? What breaks if this scales 10×? This quiet metacognition often catches issues before you trust the generated code too much.

The "shower insight" phenomenon – breakthroughs that come during unfocused moments – works in micro-doses too. If you've been wrestling with a tricky bug and Claude is now running a longer task, let go mentally. Your brain will keep working.

Task Hygiene: Write-Only Activities

Some housekeeping tasks fit perfectly into unpredictable waits. The key: they involve outputting information, not inputting new context.

Update your notes or todo list: Capture what you've done while it's fresh. "Finished auth refactor, still need to update tests." Writing this doesn't load new context – you're externalizing what's already in your head.

Log time worked: If you track time, mark your progress now. This takes seconds and keeps records accurate. Tools like Super Productivity make this frictionless.

Note a blocker or question: Something you need to ask a colleague? Write it down before you forget. You're not solving it now – just capturing it.

Clear one notification: A single Slack DM, not the whole channel. One quick reply, then back. The risk is real here: one notification leads to five. Set a hard boundary.

Bookmark for later: That article someone shared? Interesting library you want to explore? Bookmark it. Don't read it. Reading loads new context; bookmarking just queues it for later.

The rule: if it involves reading or absorbing new information, it's not a wait-time activity. You're capturing and organizing, not consuming.

The Context-Destroyers

Some activities feel productive during waits but actually sabotage your flow.

Checking Slack or Teams: "Just a quick glance" is never quick. You'll see a message that triggers a thought that demands a response. Even if you don't respond, you're now thinking about it. Attention residue is real.

Social media: Twitter, Reddit, Hacker News. The dopamine hit from novel content makes focused work feel boring afterward. You'll return to Claude's output with diminished engagement.

Starting a different task: "Might as well work on something else while I wait." Now you have two half-finished tasks. When Claude finishes, you'll either ignore it (wasting the compute) or context-switch (paying the cost twice).

Refreshing obsessively: Watching for output doesn't make it arrive faster. It keeps you in anxious waiting mode instead of recovery mode. Check once, then disengage.

Email: Even "quick" email replies require loading someone else's context, formulating a response, and making decisions. This is real work, not a break.

The "productive procrastination" trap is particularly dangerous. Starting another task feels efficient. But context-switching costs apply in both directions. You'll pay to switch away from your current work, then pay again to switch back. Two partial tasks with overhead on both beats one completed task.

One exception: If the wait is genuinely long–10+ minutes – consider whether Claude is the right tool for this task. Could you break it into smaller pieces? A 15-minute agent run might be better as three 5-minute steps with checkpoints.

Quick Reference: Match Activity to Wait

Wait length	Uncertainty	Best activities
30 sec – 1 min	Low	Posture check, deep breaths, 20-20-20
1-3 min	Medium	Re-read prompt, scan surrounding code, hydrate
3-5 min	Medium	Draft next instruction, mental walkthrough, stretch
5+ min	High	Diffuse thinking, update notes, short walk
Unknown/long	High	Set mental checkpoint, then diffuse mode

When uncertain, default to lower-commitment activities. You can always extend a stretch if the wait continues. You can't un-read that Slack message.

The Opportunity in Waiting

Developers have always waited – for compilers, builds, tests, deployments. But AI tool waits are different. They're shorter, more frequent, and unpredictable. A compile might take 3 minutes every time; Claude might take 30 seconds or 10 minutes for similar-looking tasks.

This unpredictability changes the calculus. You can't start a meaningful side task during a 30-second wait, but you also can't just zone out for what might become 5 minutes. The strategies in this guide are designed for exactly this uncertainty.

Developers who use these waits well gain an edge. They stay fresher mentally. They avoid the context-switching costs that fragment focus. They let diffuse thinking work on problems in the background.

The waits aren't lost time. They're a feature you didn't know you needed.

Related reading:

⏳ The Anti-Productivity Guide: Embrace Your 4,000 Weeks with Super Productivity

Johannes Millan — Tue, 18 Nov 2025 19:30:02 +0000

“You will never get everything done — and that’s the point.”

— Oliver Burkeman, Four Thousand Weeks

Introduction: The Myth of the Infinite To-Do List

The productivity world promises a comforting fantasy: with the right system, you can finally get everything done.

Burkeman dismantles this myth. A human life contains roughly 4,000 weeks, and your task list will always grow faster than your capacity. Accepting this is liberating — especially for users of Super Productivity, a tool often used to squeeze in more work.

The shift is simple but profound:

Super Productivity shouldn’t be a tool to maximize output. It should be a tool to enforce constraint and help you choose what deserves your attention — and what you’re willing to let go.

1. The To-Do List: A Graveyard of Impossible Demands

We treat long to-do lists as signs of control. In reality, they often reflect infinite desire confronting finite time.

The Problem: Infinite Demands vs. Finite Attention

Completing tasks doesn’t reduce the list — it creates more space for new demands. This leads to the constant, corrosive sense of falling behind.

Burkeman’s critique is blunt:

You feel like you never do enough because you can never do enough.

💡 Super Productivity Tip: Partition the Infinite from the Finite

Turn the app into a finitude enforcement system:

1. Inbox & Projects → “The Graveyard”

Your repository of everything: ideas, desires, obligations, fantasies, long-term maybes.

You don't try to empty it — you use it to keep infinite demands out of your head.

2. Today View → Strictly Finite

Limit the “Today” list to the three essential tasks.

If it’s not critical, it stays in the graveyard.

This transforms Super Productivity into a tool for focus via constraint, not expansion.

2. Escaping the Efficiency Trap: Fixed Time Beats Faster Work

The efficiency trap says: “If I just work faster, I’ll finally be on top of things.”

That moment never comes.

The more efficiently you work, the more you’re assigned. Speed only expands expectations.

The Problem: When Tasks Control Your Day

We usually let tasks run until they’re done. This allows the task to dictate your day, not your priorities or values. Reflection, leisure, or strategic thinking get sidelined.

💡 Super Productivity Tip: Timebox the Day, Not the Task

1. Fixed Schedule, Flexible Progress

Block time in the Schedule or use the Focus Timer:

Example: 09:00–11:00 is Project Alpha.

At 11:00, you stop — done or not.

2. Incompletion Is a Feature

The timebox sets the boundary.

This protects you from the “just 10 more minutes” trap.

3. Add Slack Blocks

Create recurring tasks titled “Slack,” “Chaos Buffer,” or “Contingency.”

If the block goes unused, you gain genuine rest — not another chance to cram in extra work.

3. The Necessity of Rest: Doing Nothing for Its Own Sake

True rest is pointless.

Not “recharging for productivity,” but leisure as a standalone good.

The Problem: We’ve Industrialized Rest

We turn reading into “personal development” and hiking into “creativity boosts.”

Once leisure becomes a tool for future output, it stops being leisure.

💡 Super Productivity Tip: Protect Rest in Your Logs and Reminders

1. Breaks as Hard Boundaries

Use break reminders (or a scheduled “Break” task) as non-negotiable stops.

When the timer fires, step away.

2. Reframe the Worklog

Don’t use the Worklog to judge yourself.

Use it to see what you actually chose to pay attention to.

Finishing the day and seeing clear stop-times is a success, not a failure.

3. Track Long-Term Work Slowly

For writing, coding, or creative work, track time invested, not closeness to completion.

Reward patience instead of speed.

4. The Cosmic Humiliation: You’re Not in Control — and That’s Fine

Burkeman’s final lesson is about relinquishing control.

We over-engineer our days because we fear chaos.

But chaos is inevitable.

The Problem: Planning for Perfection

Hyper-optimized plans collapse on contact with reality.

Life doesn’t follow Gantt charts.

💡 Super Productivity Tip: Plan for Response, Not Control

1. Integrations as Chaos Filters

GitHub, GitLab, Jira — they are infinite input streams.

Use integrations to pull in only the single most important issue, not the entire queue.

2. Triage Interruptions Gracefully

When you’re interrupted:

Move the current task to Paused
Reschedule it for tomorrow
Log the interruption

This ritual turns chaos into part of your official workflow — not a personal failing.

Conclusion: A Finitude-First Productivity System

Four Thousand Weeks is not anti-tool.

It is pro-limits — pro-reality.

Super Productivity becomes a finitude-aligned system when you:

Limit “Today” to the essential few
Timebox your attention instead of chasing completion
Protect rest with hard boundaries
Treat interruptions as part of the plan, not deviations

The goal is not to win the productivity game.

The goal is to use your finite number of weeks for what truly matters — and neglect everything else with clarity and peace.

The Developer’s Focus Problem: Why Your To-Do App Is Failing You (and What Actually Works)

Johannes Millan — Fri, 31 Oct 2025 10:58:46 +0000

The Developer’s Focus Problem: Why Your To-Do App Is Failing You (and What Actually Works)

💡 Meta Summary

Stop managing tasks and start managing focus. Most to-do apps are built for managers, flooding developers with notifications and killing deep work. This guide breaks down the science of developer productivity — from context switching to attention residue — and reveals the tools designed to protect your focus.

1. The “Productivity” Paradox

You have ten tabs open, three PRs to review, a Jira ticket half done, and a Slack ping blinking in your periphery. You open your “productivity” app—only to spend ten more minutes reorganizing tasks. Sound familiar?

Most to-do apps are built for managers, not makers. They optimize for visibility, reporting, and delegation—not for deep, focused, cognitive work. For developers, productivity isn’t about crossing off boxes; it’s about sustaining flow and reducing friction. This article explores the cognitive science behind developer focus—why most tools break it—and what actually supports it.

2. The Developer’s Reality: A War on Focus

The High Cost of Interruption

Interruptions aren’t harmless. Research by Gloria Mark (UC Irvine) found that after a single interruption, it takes an average of 23 minutes 15 seconds to return to the original task—while stress levels rise as workers rush to compensate (Mark et al., 2008, CHI Conference on Human Factors in Computing Systems). For developers, whose work depends on fragile mental context, every notification is an ambush.

The Attention Residue Problem

Even voluntary task switches leave traces. Psychologist Sophie Leroy called this attention residue—the lingering thoughts from Task A that reduce focus on Task B (Leroy 2009, Organizational Behavior and Human Decision Processes). Most modern productivity tools amplify this by fragmenting your mental space across lists, boards, and “inboxes.”

The Deep Work Fallacy

“Deep Work,” popularized by Cal Newport (2016), means cognitively demanding work in a distraction-free state. Ironically, many “deep work” apps undermine that very state with gamification, social feeds, and push alerts—the same attention traps that deep work was meant to escape.

3. What Developers Actually Need from a To-Do App

To protect focus, a developer’s toolset must align with cognitive principles—not corporate reporting logic.

1. Speed and Flow (Reduce Cognitive Load)

Every second spent managing your tool is a second lost from code.

Keyboard-first navigation and quick-capture shortcuts.
Instant response: no lag, no modal dance, no wait.
Cross-platform parity: works identically on Linux, macOS, Windows, and Android—so your workflow stays consistent everywhere.

2. Context Integration (Minimize Context Switching)

Your tasks already live in GitHub, Jira, or your inbox.

Integrate, don’t duplicate.
Keep integrations optional so they help rather than distract.
Code-aware time tracking: link commits and issues automatically to understand where your focus really went.

3. Focus & Timeboxing Tools (Manage Attention)

Listing tasks is easy; executing them well requires rhythm.

Pomodoro or other focus timers and daily planning encourage structured bursts of focus.
Research on ultradian rhythms shows the brain performs best in 90–120 minute cycles followed by rest (Kleiber et al., 2002).

4. Local-First and Offline (Speed and Autonomy)

Cloud sync is convenient—until it slows you down. Local-first apps read and write directly on your device, making every action instantaneous. For developers, that means:

Immediate feedback at native speed.
Optional sync, only when you choose.
Full control with no logins or remote failures. Local-first isn’t nostalgia—it’s the fastest route back into flow.

5. Privacy and Data Ownership (Preserve Trust)

Task lists contain sensitive data—clients, projects, thoughts.

No telemetry, forced accounts, or opaque cloud storage.
Full export and offline use should be standard, not premium.

4. What Developers Don’t Need

The productivity industry loves to bolt dopamine mechanics onto serious work. Developers don’t benefit from that—they pay for it in fragmented attention.

1. Gamified Streaks and Badges

What motivates developers is mastery and progress, not arbitrary streaks. According to Deci & Ryan’s Self-Determination Theory (2000, American Psychologist), external rewards can suppress intrinsic motivation in creative problem-solving. A “5-day streak” might feel good, but it doesn’t make your code better.

2. Social Dashboards and “Visibility” Metrics

These features are built for managers to measure activity, not for individuals to think clearly. They create pressure to look productive instead of being effective—and they turn private focus into public performance.

3. “AI Productivity” Noise

Unsolicited prompts and predictive nudges often interrupt more than they assist. Good AI should quiet the interface, not clutter it with guesses. A tool that helps you plan is useful; one that plans for you is another distraction.

4. Forced Cloud Sync and Paywalls

When a simple action depends on a server handshake, your focus is already broken. Local-first, open tools remove that latency tax—and eliminate the anxiety of being locked out of your own work.

5. The Open-Source Advantage: Built by Makers, for Makers

Open-source tools work differently because their incentives are aligned with their users.

No growth hacking: success equals usefulness, not screen time.
Transparency: you can audit, extend, or self-host.
Community: improvements arise from real workflows, not marketing OKRs.

“This is why tools like Super Productivity exist. Built by developers for developers, it treats GitHub and Jira tasks as first-class citizens, runs entirely offline, and puts focus tools—like time tracking and Pomodoro—front and center.”

6. Comparison: Developer-Friendly Task Managers

App	Open Source	Offline Support	Integrations	Core Philosophy
Super Productivity	✅ Yes	✅ Full Local-First	GitHub, Jira, GitLab, CalDAV	Focus & Context: unify all tasks into one “Now” list.
Todoist	❌ No	❌ Limited	Zapier / IFTTT	Omni-Capture: collect everything in one place.
TickTick	❌ No	❌ Limited	Basic CalDAV	Feature-Rich: habits + calendar + lists.
Taskwarrior	✅ Yes	✅ Full Local	CLI / scripts	Power User Tool: terminal precision.
Obsidian (Tasks)	✅ Yes	✅ Full Local-First	Markdown / manual	Knowledge Graph: tasks within your “second brain.”

7. The Future: Measuring What Matters (Impact, Not Activity)

Modern research shows productivity is multi-dimensional. The SPACE framework (Forsgren et al., 2021, Microsoft Research) and DORA metrics emphasize satisfaction, flow, and impact—not sheer output. A focus-first app helps you track time spent in deep work, not just tasks completed. True productivity is sustainable performance: deliberate effort, meaningful results, and the ability to shut the laptop at day’s end.

8. Conclusion: Reclaim Your Focus

Stop letting tools built for management dictate how you build software. The best to-do app for developers is one you open only a few times a day—to plan, reflect, and close your day’s loop. The rest of the time, it should disappear.

Don’t look for a tool to manage your tasks.

Look for one that respects your attention.

📚 References

Deci, E. L., & Ryan, R. M. (2000). Self-Determination Theory and the Facilitation of Intrinsic Motivation, Social Development, and Well-Being. American Psychologist.
Forsgren, N., Storey, M.-A., et al. (2021). The SPACE of Developer Productivity. Microsoft Research.
Kleiber, D. A., et al. (2002). The Experience of Leisure in Adulthood. Psychology Press.
Leroy, S. (2009). Why Is It So Hard to Do My Work? Organizational Behavior and Human Decision Processes.
Mark, G., Gonzalez, V. M., & Harris, J. (2008). No Task Left Behind? Examining the Nature of Fragmented Work. Proceedings of the SIGCHI Conference on Human Factors in Computing Systems.
Newport, C. (2016). Deep Work: Rules for Focused Success in a Distracted World. Grand Central Publishing.

Open-Source Productivity Apps in 2025: A Careful Comparison

Johannes Millan — Sat, 25 Oct 2025 14:20:24 +0000

🧭 Open-Source Productivity Apps in 2025: A Careful, No-Hype Comparison

If you value transparency, control, and long-term reliability, open-source productivity tools offer serious alternatives to commercial services.

They let you keep ownership of your data, work offline, and adapt the software to your workflow — without ads or telemetry.

This article presents an overview of some of the most relevant open-source productivity apps in 2025 — including Super Productivity, Vikunja, Joplin, Taskwarrior, Trilium Next, OpenProject, and others.

✅ Evaluation Criteria

Philosophy & Focus — individual vs team use; tasks vs notes
Platform Support — Linux, macOS, Windows, Android, iOS, Web
Privacy & Offline Capability — data storage model and telemetry
Integrations & Extensibility — plug-ins, APIs, sync options
Self-Hosting & Sync — WebDAV, CalDAV, dedicated servers
Community & Maintenance — release frequency and sustainability

🔍 The Contenders (2025)

All projects listed are open source and have seen updates in 2024 or 2025.

App	License	Platforms	Highlights
Super Productivity	MIT	Linux, macOS, Windows, Android, Web	Tasks, time-tracking, timeboxing, calendar & GitHub/GitLab/Jira integrations; plugin system and various optional productivity tools
Vikunja	GPL-3.0	Web, Linux, macOS, Windows, Android, iOS	Self-hosted task and project manager; lists, Kanban boards, sharing, REST API, offline-first apps
Joplin	AGPL-3.0-or-later ¹	Linux, macOS, Windows, Android, iOS, Terminal	Notes + tasks, plugin ecosystem, multiple sync back-ends
Taskwarrior	MIT	Linux, macOS, Windows (CLI)	Plain-text CLI task tracking with hooks
Trilium Notes	AGPLv3	Desktop & Web	Hierarchical notes, encryption per note, community-maintained since 2024
OpenProject	GPLv3	Web	Team project management (Gantt, Agile, time tracking)
Nextcloud Tasks	AGPLv3	Web + Mobile Clients	CalDAV-based task sync within Nextcloud
Planify	GPLv3	Linux (GTK)	Simple desktop task app; optional Todoist/Nextcloud sync
Organice	AGPLv3	Web	Org-mode-compatible; sync via WebDAV, Dropbox, GitLab
todo.txt CLI	GPL-3.0	All (shell)	Minimal plain-text task manager

¹ Joplin Server uses an additional “Personal Use License” restricting commercial hosting.

🖼 Interface Snapshots

Your browser does not support the video tag. You can download the clip here.

Super Productivity desktop: focus timer, tasks, and calendar side panel in one view.

Joplin showing split-view Markdown editing for notes and tasks.

Trilium Next presenting hierarchical notes with rich text widgets.

OpenProject’s work package board with collaborative task tracking.

Nextcloud Tasks list with shared project contexts and due dates.

Planify on GNOME offering task grouping and optional cloud sync.

Organice displaying Org-mode tasks with agenda navigation.

todo.txt CLI in action: lightweight plain-text task management.

Vikunja’s Kanban board with swim lanes and quick actions.

🧩 Detailed Comparison

🧠 Philosophy & Intended Use

Super Productivity — Built for individuals and developers with a focus on deep work and easy task organization. Combines task management, time-tracking, timeboxing, and calendar integration. Integrates with GitHub, GitLab, and Jira.
Vikunja — A self-hosted task and project manager positioned as an open-source alternative to Todoist or ClickUp. Supports lists, Kanban boards, subtasks, and team collaboration. Offline-capable mobile and desktop clients available.
Joplin — A note-centric app supporting to-do checkboxes. Core clients under AGPL-3.0-or-later; the self-hosted sync server requires accepting its personal-use license. Offers Markdown editing and plugin extensions.
Taskwarrior — CLI tool for GTD-style task management; fast, fully local and scriptable. Appeals to terminal-oriented users.
Trilium Next — Community-maintained fork of Trilium Notes (since 2024). Focused on hierarchical note-taking and PKM (Personal Knowledge Management).
OpenProject — Web application for collaborative project management; features Agile boards, Gantt charts, and time tracking.
Nextcloud Tasks — Lightweight CalDAV task manager for users already hosting Nextcloud.
Planify — Linux GTK app with optional sync to Todoist and Nextcloud; ideal for GNOME users.
Organice — Web front-end for Org-mode (.org) files; bridges Emacs workflows and the browser.
todo.txt CLI — Plain-text task lists managed directly from the terminal; scriptable and versionable.

💻 Platform Support

Super Productivity — Linux, macOS, Windows; Android version with timeboxing and calendar integration; web app available.
Vikunja — Web app plus native clients for Android, iOS, and desktop (via PWA or community builds).
Joplin — Desktop (Linux/macOS/Windows), mobile (Android/iOS), and terminal client.
Taskwarrior — CLI for Linux, macOS, Windows; several unofficial GUIs.
Trilium Next — Desktop and web versions; self-hostable Node.js server.
OpenProject — Web-based; self-hosted or cloud.
Nextcloud Tasks — Web interface; accessible through mobile CalDAV clients (DAVx⁵).
Planify — Linux (GNOME/GTK); available via Flathub.
Organice — Web application; self-hostable.
todo.txt — Works on any platform with a shell.

🔐 Privacy & Offline Use

Super Productivity — Offline by default; no telemetry. Sync via file, WebDAV (including Nextcloud), or Dropbox with optional encryption.
Vikunja — Fully self-hosted with optional public sharing; offline-first clients. No tracking or external dependencies.
Joplin — Offline-first; sync via WebDAV, Nextcloud, Dropbox, or filesystem.
Taskwarrior — Local only unless using optional encrypted Taskserver.
Trilium Next — Local and self-hosted; encryption per note.
OpenProject — Web-based; privacy depends on hosting.
Nextcloud Tasks — Privacy inherits Nextcloud’s configuration.
Planify — Local or optional cloud sync.
Organice — Privacy depends on chosen sync backend; self-hosting possible.
todo.txt — Local files only.

⚙️ Integrations & Extensibility

Super Productivity — Integrates with GitHub, GitLab, Jira, and OpenProject; supports CalDAV and WebDAV sync. Plugin API planned.
Vikunja — REST API for integrations and automation; supports import from Todoist, Trello, and JSON.
Joplin — Plugin architecture for Markdown extensions and integrations.
Taskwarrior — Scriptable via hooks; supports data exports and reports.
Trilium Next — JavaScript-based scripting; custom widgets and relationships.
OpenProject — Integrates with GitHub, GitLab, LDAP, Jenkins, and calendar systems.
Nextcloud Tasks — CalDAV interoperability.
Planify — Integrates with Todoist/Nextcloud APIs; no extension system yet.
Organice — Integrates through Org-mode files and WebDAV/Dropbox.
todo.txt — Integrates through shell scripts and cron automation.

☁️ Sync & Self-Hosting

Super Productivity — WebDAV, Nextcloud, Dropbox; no central server.
Vikunja — Self-hosted server written in Go; Docker images and official mobile apps provided.
Joplin — Sync via Joplin Cloud, WebDAV, Nextcloud, Dropbox, OneDrive, filesystem.
Taskwarrior — Optional self-hosted Taskserver.
Trilium Next — Node.js server for sync.
OpenProject — Full web stack, packaged Docker images available.
Nextcloud Tasks — Hosted inside Nextcloud; sync via CalDAV.
Planify — Local or Todoist/Nextcloud sync.
Organice — Uses WebDAV/Dropbox/GitLab for sync.
todo.txt — Manual sync (e.g., via Git or cloud folder).

👥 Community & Maintenance (2024–2025)

Super Productivity — Active development; regular releases.
Vikunja — Active GitHub project with steady releases through 2025.
Joplin — Large, active community and plugin ecosystem.
Taskwarrior — Mature and stable; moderate activity.
Trilium Next — Maintained by open community since 2024.
OpenProject — Maintained by OpenProject GmbH with enterprise backing.
Nextcloud Tasks — Part of the larger Nextcloud community.
Planify — Regular updates via Flathub.
Organice — Version 1.2 (2025) introduces Parcel build system.
todo.txt — Stable; community forks remain active.

🧱 Security Notes for Self-Hosting

When self-hosting apps like Vikunja, Joplin Server, Trilium Next, or OpenProject:

Enable HTTPS (TLS) and strong authentication.
Keep Docker images and dependencies updated.
Restrict WebDAV/CalDAV endpoints to authenticated users.

Poorly configured self-hosted instances are a common privacy risk.

🎯 Which Tool Fits Which User?

Use Case	Recommended Apps
Developer tracking issues and time	Super Productivity
Team project and Kanban management	Vikunja or OpenProject
Note-heavy workflow	Joplin or Trilium Next
CLI-based workflow	Taskwarrior or todo.txt
Self-hosted Nextcloud setup	Nextcloud Tasks or Planify
Emacs/Org-mode ecosystem	Organice

🧭 Conclusion

There is no universal “best” open-source productivity app — only the one that fits your workflow.

Super Productivity excels for individuals needing task management and time tracking with developer integrations.
Vikunja offers a self-hosted, full-featured task manager suitable for both personal and team use.
Joplin and Trilium Next shine for note-driven workflows.
OpenProject targets professional teams and organizations.
todo.txt and Taskwarrior remain lightweight, scriptable classics.

Each project reflects a different philosophy — from simplicity to full-stack collaboration — proving that open source continues to deliver genuine choice and innovation in productivity software.

How to Achieve Deep Work: A Science-Based Guide to Peak Focus and Meaningful Output

Johannes Millan — Sat, 25 Oct 2025 14:17:36 +0000

How to Achieve Deep Work: A Science-Based Guide to Peak Focus and Meaningful Output

In a world of constant notifications, deep work has become both rare and immensely valuable.

Most professionals spend their days in reactive mode — jumping between emails, chats, and meetings. Yet the ability to sustain distraction-free concentration is what drives true innovation, quality, and satisfaction.

This guide outlines practical, science-based strategies for building your deep work practice — not through willpower alone, but by working with your brain’s natural limits.

What Is Deep Work (and Why It Matters)

Deep work, a term coined by computer science professor Cal Newport, is “professional activity performed in a state of distraction-free concentration that pushes your cognitive capabilities to their limit.”¹

It’s not about being busy or checking off tasks — it’s about entering a state where:

Your full attention is devoted to one demanding task
Time seems to disappear
You produce high-quality work that’s difficult to replicate
You experience what psychologist Mihaly Csikszentmihalyi called flow — complete immersion and intrinsic satisfaction²

The Hidden Cost of Task-Switching

Research by Dr. Sophie Leroy uncovered the concept of attention residue — the lingering focus that remains on a previous task even after you switch to something new.³

Every “quick check” of messages or email leaves part of your mind behind, fragmenting concentration for up to 20 minutes.

In short: context switching is the enemy of deep work.

The Deep Work Advantage

Newport argues that the ability to perform deep work is becoming rarer and more valuable.

Those who cultivate it consistently produce more meaningful results — not through longer hours, but through undivided attention.

The Biological Limits of Focus

Even elite performers — violinists, chess grandmasters, and mathematicians — can only sustain about four hours of deep, focused work per day.⁴

This isn’t weakness; it’s physiology.

The brain consumes immense energy during concentrated effort. After several hours, mental fatigue sets in and output quality drops sharply.

Practical takeaway:

Start small: 60–90 minutes daily
Build gradually to 3–4 hours in focused blocks
Treat rest and recovery as part of the system

Four Ways to Structure Deep Work

Newport describes four philosophies for integrating deep work into real life:

1. Monastic — Total Isolation

Completely remove shallow obligations.

Ideal for writers or researchers.

Example: Bill Gates’ “Think Weeks” in total isolation.

2. Bimodal — Deep/Reactive Cycles

Alternate between full days of deep work and administrative periods.

Ideal for professionals who can batch meetings or emails.

3. Rhythmic — Daily Routine

Schedule deep work at fixed times each day — even 60 minutes of consistency compounds fast.

Ideal for most knowledge workers.

4. Journalistic — Opportunistic Focus

Drop into deep work whenever time allows.

Ideal for experienced practitioners with strong focus discipline.

Building Your Deep Work System

1. Design Your Environment

Create a physical and digital setup that signals focus:

Keep only essential tools visible
Control noise and visual clutter
Use browser blockers or airplane mode
Let others know: “In focus mode until X.”

Your workspace should make distraction inconvenient.

2. Develop a Pre-Work Ritual

A short, repeatable ritual tells your brain it’s time to concentrate:

Review your one clear objective
Tidy your workspace
Start a timer
Take three slow breaths
Begin with the smallest next action

After each session, record what you achieved and plan your next step.

This simple reflection dramatically improves consistency.

3. Strengthen Your Focus Muscles

Attention is trainable — like physical strength.

Track your baseline. How long can you focus before checking something?
Increase gradually. Add five minutes of uninterrupted focus each week.
Build boredom tolerance. Walk without your phone. Wait in line without scrolling.
Protect peak energy hours. Schedule creative or strategic work when you feel sharpest.

Your goal isn’t perfection — it’s steady adaptation.

4. Contain the Shallow Work

Shallow work — meetings, coordination, admin — must be deliberately contained.

Batch it: dedicate specific time slots (e.g., 11:30 and 16:00).
Automate or delegate whenever possible.
Set communication expectations: “Responses may take up to X hours.”
Decline low-value meetings: protect your prime hours.

As Newport writes, “Clarity about what matters provides clarity about what does not.”¹

Tracking and Measuring Deep Work

You can’t improve what you don’t measure.

Key metrics to monitor:

Deep work hours: uninterrupted, high-cognitive time
Output quality: subjective score (1–10)
Flow frequency: how often you felt fully absorbed

A weekly reflection helps spot patterns — when you focus best, what breaks your rhythm, and where you’re wasting effort.

💡 Super Productivity users often track these metrics directly in their task notes or by using the focus mode feature of the app.

Common Obstacles and How to Overcome Them

“I’m constantly interrupted.”

Start early-morning blocks before messages start. Use visible signals — headphones, “Focus Mode,” or calendar blocks.

“I can’t concentrate for long.”

Begin with 15-minute sprints. Gradually expand. Meditation or mindfulness training accelerates this adaptation.

“My work requires constant availability.”

Batch reactive windows and communicate them clearly. You’ll likely find far fewer “emergencies” than you expect.

The Payoff: More Than Productivity

Deep work delivers exponential benefits:

Professional: Mastery of complex skills, higher-quality output, increased career capital
Personal: Lower stress, greater satisfaction, and genuine progress
Psychological: Regular flow states, purpose, and cognitive resilience

Focus is not about discipline alone — it’s about design.

Once you align your environment, habits, and tools, deep work becomes your natural default.

Your 30-Day Deep Work Challenge

Week 1: Set up your environment and schedule one 60-minute block daily.

Week 2: Develop rituals and track sessions.

Week 3: Identify your best focus times and extend sessions to 90 minutes.

Week 4: Review, refine, and integrate your routine permanently.

Start small.

Protect one block today.

Silence everything.

And work deeply — your future self will thank you.

References

Newport, C. (2016). Deep Work: Rules for Focused Success in a Distracted World. Grand Central Publishing. ↩
Csikszentmihalyi, M. (1990). Flow: The Psychology of Optimal Experience. Harper & Row. ↩
Leroy, S. (2009). Why is it so hard to do my work? The challenge of attention residue when switching between work tasks. Organizational Behavior and Human Decision Processes, 109(2), 168–181. ↩
Ericsson, K. A. et al. (1993). The Role of Deliberate Practice in the Acquisition of Expert Performance. Psychological Review, 100(3), 363–406. ↩

Productivity

Johannes Millan — Fri, 24 Oct 2025 08:10:40 +0000

Open-Source Productivity Apps in 2025: A Careful Comparison

Johannes Millan — Mon, 20 Oct 2025 10:44:22 +0000

✅ Evaluation Criteria

Philosophy & Focus — individual vs team use; tasks vs notes
Platform Support — Linux, macOS, Windows, Android, iOS, Web
Privacy & Offline Capability — data storage model and telemetry
Integrations & Extensibility — plug-ins, APIs, sync options
Self-Hosting & Sync — WebDAV, CalDAV, dedicated servers
Community & Maintenance — release frequency and sustainability

🔍 The Contenders (2025)

All projects listed are open source and have seen updates in 2024 or 2025.

App	License	Platforms	Highlights
Super Productivity	MIT	Linux, macOS, Windows, Android, Web	Tasks, time-tracking, timeboxing, calendar & GitHub/GitLab/Jira integrations; plugin system and various optional productivity tools
Vikunja	GPL-3.0	Web, Linux, macOS, Windows, Android, iOS	Self-hosted task and project manager; lists, Kanban boards, sharing, REST API, offline-first apps
Joplin	AGPL-3.0-or-later ¹	Linux, macOS, Windows, Android, iOS, Terminal	Notes + tasks, plugin ecosystem, multiple sync back-ends
Taskwarrior	MIT	Linux, macOS, Windows (CLI)	Plain-text CLI task tracking with hooks
Trilium Notes	AGPLv3	Desktop & Web	Hierarchical notes, encryption per note, community-maintained since 2024
OpenProject	GPLv3	Web	Team project management (Gantt, Agile, time tracking)
Nextcloud Tasks	AGPLv3	Web + Mobile Clients	CalDAV-based task sync within Nextcloud
Planify	GPLv3	Linux (GTK)	Simple desktop task app; optional Todoist/Nextcloud sync
Organice	AGPLv3	Web	Org-mode-compatible; sync via WebDAV, Dropbox, GitLab
todo.txt CLI	GPL-3.0	All (shell)	Minimal plain-text task manager

¹ Joplin Server uses an additional “Personal Use License” restricting commercial hosting.

🧩 Detailed Comparison

🧠 Philosophy & Intended Use

Super Productivity — Built for individuals and developers with a focus on deep work and easy task organization. Combines task management, time-tracking, timeboxing, and calendar integration. Integrates with GitHub, GitLab, and Jira.
Vikunja — A self-hosted task and project manager positioned as an open-source alternative to Todoist or ClickUp. Supports lists, Kanban boards, subtasks, and team collaboration. Offline-capable mobile and desktop clients available.
Joplin — A note-centric app supporting to-do checkboxes. Core clients under AGPL-3.0-or-later; the self-hosted sync server requires accepting its personal-use license. Offers Markdown editing and plugin extensions.
Taskwarrior — CLI tool for GTD-style task management; fast, fully local and scriptable. Appeals to terminal-oriented users.
Trilium Next — Community-maintained fork of Trilium Notes (since 2024). Focused on hierarchical note-taking and PKM (Personal Knowledge Management).
OpenProject — Web application for collaborative project management; features Agile boards, Gantt charts, and time tracking.
Nextcloud Tasks — Lightweight CalDAV task manager for users already hosting Nextcloud.
Planify — Linux GTK app with optional sync to Todoist and Nextcloud; ideal for GNOME users.
Organice — Web front-end for Org-mode (.org) files; bridges Emacs workflows and the browser.
todo.txt CLI — Plain-text task lists managed directly from the terminal; scriptable and versionable.

💻 Platform Support

Super Productivity — Linux, macOS, Windows; Android version with timeboxing and calendar integration; web app available.
Vikunja — Web app plus native clients for Android, iOS, and desktop (via PWA or community builds).
Joplin — Desktop (Linux/macOS/Windows), mobile (Android/iOS), and terminal client.
Taskwarrior — CLI for Linux, macOS, Windows; several unofficial GUIs.
Trilium Next — Desktop and web versions; self-hostable Node.js server.
OpenProject — Web-based; self-hosted or cloud.
Nextcloud Tasks — Web interface; accessible through mobile CalDAV clients (DAVx⁵).
Planify — Linux (GNOME/GTK); available via Flathub.
Organice — Web application; self-hostable.
todo.txt — Works on any platform with a shell.

🔐 Privacy & Offline Use

Super Productivity — Offline by default; no telemetry. Sync via file, WebDAV (including Nextcloud), or Dropbox with optional encryption.
Vikunja — Fully self-hosted with optional public sharing; offline-first clients. No tracking or external dependencies.
Joplin — Offline-first; sync via WebDAV, Nextcloud, Dropbox, or filesystem.
Taskwarrior — Local only unless using optional encrypted Taskserver.
Trilium Next — Local and self-hosted; encryption per note.
OpenProject — Web-based; privacy depends on hosting.
Nextcloud Tasks — Privacy inherits Nextcloud’s configuration.
Planify — Local or optional cloud sync.
Organice — Privacy depends on chosen sync backend; self-hosting possible.
todo.txt — Local files only.

⚙️ Integrations & Extensibility

Super Productivity — Integrates with GitHub, GitLab, Jira, and OpenProject; supports CalDAV and WebDAV sync. Plugin API planned.
Vikunja — REST API for integrations and automation; supports import from Todoist, Trello, and JSON.
Joplin — Plugin architecture for Markdown extensions and integrations.
Taskwarrior — Scriptable via hooks; supports data exports and reports.
Trilium Next — JavaScript-based scripting; custom widgets and relationships.
OpenProject — Integrates with GitHub, GitLab, LDAP, Jenkins, and calendar systems.
Nextcloud Tasks — CalDAV interoperability.
Planify — Integrates with Todoist/Nextcloud APIs; no extension system yet.
Organice — Integrates through Org-mode files and WebDAV/Dropbox.
todo.txt — Integrates through shell scripts and cron automation.

☁️ Sync & Self-Hosting

Super Productivity — WebDAV, Nextcloud, Dropbox; no central server.
Vikunja — Self-hosted server written in Go; Docker images and official mobile apps provided.
Joplin — Sync via Joplin Cloud, WebDAV, Nextcloud, Dropbox, OneDrive, filesystem.
Taskwarrior — Optional self-hosted Taskserver.
Trilium Next — Node.js server for sync.
OpenProject — Full web stack, packaged Docker images available.
Nextcloud Tasks — Hosted inside Nextcloud; sync via CalDAV.
Planify — Local or Todoist/Nextcloud sync.
Organice — Uses WebDAV/Dropbox/GitLab for sync.
todo.txt — Manual sync (e.g., via Git or cloud folder).

👥 Community & Maintenance (2024–2025)

Super Productivity — Active development; regular releases.
Vikunja — Active GitHub project with steady releases through 2025.
Joplin — Large, active community and plugin ecosystem.
Taskwarrior — Mature and stable; moderate activity.
Trilium Next — Maintained by open community since 2024.
OpenProject — Maintained by OpenProject GmbH with enterprise backing.
Nextcloud Tasks — Part of the larger Nextcloud community.
Planify — Regular updates via Flathub.
Organice — Version 1.2 (2025) introduces Parcel build system.
todo.txt — Stable; community forks remain active.

🧱 Security Notes for Self-Hosting

When self-hosting apps like Vikunja, Joplin Server, Trilium Next, or OpenProject:

Enable HTTPS (TLS) and strong authentication.
Keep Docker images and dependencies updated.
Restrict WebDAV/CalDAV endpoints to authenticated users.

Poorly configured self-hosted instances are a common privacy risk.

🎯 Which Tool Fits Which User?

Use Case	Recommended Apps
Developer tracking issues and time	Super Productivity
Team project and Kanban management	Vikunja or OpenProject
Note-heavy workflow	Joplin or Trilium Next
CLI-based workflow	Taskwarrior or todo.txt
Self-hosted Nextcloud setup	Nextcloud Tasks or Planify
Emacs/Org-mode ecosystem	Organice

🧭 Conclusion

There is no universal “best” open-source productivity app — only the one that fits your workflow.

Super Productivity excels for individuals needing task management and time tracking with developer integrations.
Vikunja offers a self-hosted, full-featured task manager suitable for both personal and team use.
Joplin and Trilium Next shine for note-driven workflows.
OpenProject targets professional teams and organizations.
todo.txt and Taskwarrior remain lightweight, scriptable classics.

Each project reflects a different philosophy — from simplicity to full-stack collaboration — proving that open source continues to deliver genuine choice and innovation in productivity software.

Escaping the End-of-Summer Slump: How Habits Shape Your Productive Autumn

Johannes Millan — Thu, 28 Aug 2025 12:48:57 +0000

People do not decide their futures, they decide their habits and their habits decide their futures.

— F. M. Alexander

The end-of-summer slump is real. Days are getting shorter, vacations are over, and while your brain knows it's time to shift gears, your body is still lingering in that relaxed, free-flowing summer mode. The result? A strange in-between state where you feel both restless and stuck.

The good news: this isn’t about a lack of willpower. It’s about habits. And with the right approach, you can use this transitional moment to reset and build a rhythm that carries you smoothly into autumn.

Why Your Brain Struggles After Summer

Summer often means more freedom, more spontaneity, and fewer rigid structures. Transitioning back to routine can feel like loss—even if you secretly crave the structure. That inner resistance isn’t laziness; it’s your mind grieving the shift from openness to focus.

Psychologists call this “change resistance.” Just like the back-to-school blues we remember from childhood, your brain pushes back against new constraints. Recognizing this is important: resistance is a normal psychological response to change, not a sign that you’re doing something wrong.

How to Reset Your Rhythm

Here are some practical ways to ease yourself out of the slump and back into a flow state:

1. Start Small, Repeat Daily

Don’t aim for the perfect fall routine on day one. Instead, pick one anchor habit—like setting your daily priorities in the morning, or blocking 90 minutes for deep work—and repeat it until it sticks. Tiny wins compound.

2. Redefine "Back to Work"

Rather than seeing the end of summer as “the fun is over,” frame it as a season of focus and creation. Summer may be for exploration, autumn can be for execution. Reframing helps reduce the emotional drag.

3. Use Your Tools to Create Momentum

Apps like Super Productivity can act as scaffolding for new habits. Setting recurring tasks, timeboxing, and quick-capture notes help you build structure without overthinking. The less friction, the faster you’ll regain momentum.

4. Balance Structure with Flexibility

A common mistake after summer is over-structuring. Leave room for spontaneity—like blocking unplanned time each week. This way, you keep some of that summer spirit alive while still committing to progress.

Build Habits, Not Just Plans

The quote at the beginning says it all: your future won’t be decided by a single burst of motivation but by the habits you practice daily. Think of this transitional season as an opportunity to reset—not by chasing perfection, but by designing habits that will carry you forward.

This autumn, instead of asking "What do I want to achieve?" try asking:

"What daily habits will get me there?"

Your habits will take care of the rest.

Ready to build productive autumn habits? Download Super Productivity and create the structure you need to turn seasonal transitions into productivity wins.

Super Productivity with the GTD Method

Johannes Millan — Thu, 28 Aug 2025 12:48:03 +0000

Super Productivity with the GTD Method

The Getting Things Done (GTD) method, developed by David Allen, is a time-tested system for staying organized, reducing stress, and keeping commitments clear.

Super Productivity is a privacy-friendly, open-source productivity app that aligns naturally with GTD’s principles—without forcing you into a rigid workflow.

This guide shows you how to set up and use Super Productivity to implement GTD effectively.

1. Understanding the GTD Workflow

GTD has five key steps:

Capture – Collect everything that has your attention.
Clarify – Decide what each item means and what to do about it.
Organize – Put actionable items into the right places.
Reflect – Review regularly to keep your system current.
Engage – Do the work based on context, priority, and energy.

2. Step-by-Step GTD Setup in Super Productivity

Step 1 – Capture: Collect Everything

Go to your "Inbox" by selecting it in the left hand menu.
Then use the “Add Task” button (or keyboard shortcut) to quickly capture any task, idea, or reminder.
Keep entries short and specific—e.g., "Call supplier about delayed shipment".

💡 Tip: You can also capture tasks in a plain text file (one per bullet point) and paste them into Super Productivity directly from your clipboard.

Step 2 – Clarify: Decide the Next Step

Process your Inbox regularly (ideally daily).
For each item, ask:
- Is it actionable? If not, archive it or save as reference or delete it.
- If yes, define the next physical action clearly (e.g., “Email Lisa to confirm date” instead of “Lisa project”).
Use task notes to store supporting details.

Step 3 – Organize: Put It Where It Belongs

Super Productivity’s Projects, Tags, and Due Dates map neatly to GTD concepts:

GTD Concept	Super Productivity Feature
Projects	Project boards
Contexts (e.g., @home)	Tags (e.g., `#home`, `#office`)
Time-specific actions	Due dates & reminders
Someday/Maybe list	A dedicated “Someday” project (or tag)

Example setup:

Projects: “Website Redesign”, “Marketing Campaign”, “Personal Finance”
Tags: #call, #errand, #deepwork
Someday Project: For non-urgent ideas and “maybe later” items.

Step 4 – Reflect: Weekly Review

A weekly review keeps your GTD system trusted and current. In Super Productivity:

Filter tasks by project and tag to see outstanding work. You can do so by using the filter panel that opens when you click the filter icon button in the top right.
Check the Someday project—promote items when relevant.
Review completed tasks to track progress.
Update priorities, deadlines, and tags as needed.

Step 5 – Engage: Work with Focus

When it’s time to take action:

Use Filters to see tasks by context/tag (e.g., only #office tasks while at the office).
Sort by priority to focus on high-impact work.
Use the Pomodoro Timer or the Flow Timer to stay focused and avoid burnout.

3. Advanced GTD Practices with Super Productivity

Reference Material: Store notes or link to external documents for easy access.
Recurring Tasks: Automate regular actions (e.g., weekly reports) using repeat settings.
External Integrations: Pull tasks from GitHub, Jira, or other sources to capture all work in one place.

4. Common Pitfalls to Avoid

Over-tagging: Too many tags create friction; keep them focused.
Skipping Clarification: Don’t leave tasks vague—unclear items clog your system.
Neglecting Reviews: Without reviews, your GTD setup will quickly lose reliability.

- Too many tasks: Dare to delete and cleanup things you likely never will do.

5. Final Thoughts

GTD is about mental clarity—trusting that every commitment is captured, organized, and reviewable.

Super Productivity’s flexibility, privacy focus, and zero-cost model make it an excellent GTD tool without locking you into a proprietary ecosystem.

Start simple, refine as you go, and let the system work for you—not the other way around.

DEV Community: Johannes Millan

Why Multitasking With AI Coding Agents Breaks Down (And How I Fixed It)

The Multitasking Problem

Why tmux (Alone) Isn’t Enough

The Key Insight

Designing for Parallel AI Work

What I Built

What Changed in My Workflow

The Bigger Question

I’m Curious

7 Small Workflow Tweaks That Actually Helped My Developer Productivity

1. Time-boxing instead of todo lists

2. One tab for the current task

3. Write tomorrow's tasks today

4. Pull tasks from your issue tracker automatically

5. Track time, but not for productivity theater

6. Scheduled break reminders

7. Daily review, weekly review

Wrote a new article!

What to Do While Waiting for AI Code Assistants

Johannes Millan ・ Jan 7

What to Do While Waiting for AI Code Assistants

The Uncertain Wait Problem

Physical Resets: Drop-Instantly Activities

Context-Preserving Mental Tasks

Diffuse Thinking: Let Your Brain Work

Task Hygiene: Write-Only Activities

The Context-Destroyers

Quick Reference: Match Activity to Wait

The Opportunity in Waiting

⏳ The Anti-Productivity Guide: Embrace Your 4,000 Weeks with Super Productivity

Introduction: The Myth of the Infinite To-Do List

1. The To-Do List: A Graveyard of Impossible Demands

The Problem: Infinite Demands vs. Finite Attention

💡 Super Productivity Tip: Partition the Infinite from the Finite

2. Escaping the Efficiency Trap: Fixed Time Beats Faster Work

The Problem: When Tasks Control Your Day

💡 Super Productivity Tip: Timebox the Day, Not the Task

3. The Necessity of Rest: Doing Nothing for Its Own Sake

The Problem: We’ve Industrialized Rest

💡 Super Productivity Tip: Protect Rest in Your Logs and Reminders

4. The Cosmic Humiliation: You’re Not in Control — and That’s Fine

The Problem: Planning for Perfection

💡 Super Productivity Tip: Plan for Response, Not Control

Conclusion: A Finitude-First Productivity System

The Developer’s Focus Problem: Why Your To-Do App Is Failing You (and What Actually Works)

The Developer’s Focus Problem: Why Your To-Do App Is Failing You (and What Actually Works)

💡 Meta Summary

1. The “Productivity” Paradox

2. The Developer’s Reality: A War on Focus

The High Cost of Interruption

The Attention Residue Problem

The Deep Work Fallacy

3. What Developers Actually Need from a To-Do App

1. Speed and Flow (Reduce Cognitive Load)

2. Context Integration (Minimize Context Switching)

3. Focus & Timeboxing Tools (Manage Attention)

4. Local-First and Offline (Speed and Autonomy)

5. Privacy and Data Ownership (Preserve Trust)

4. What Developers Don’t Need

1. Gamified Streaks and Badges

2. Social Dashboards and “Visibility” Metrics

3. “AI Productivity” Noise

4. Forced Cloud Sync and Paywalls

5. The Open-Source Advantage: Built by Makers, for Makers

6. Comparison: Developer-Friendly Task Managers

7. The Future: Measuring What Matters (Impact, Not Activity)

8. Conclusion: Reclaim Your Focus

📚 References

Open-Source Productivity Apps in 2025: A Careful Comparison

🧭 Open-Source Productivity Apps in 2025: A Careful, No-Hype Comparison

✅ Evaluation Criteria

🔍 The Contenders (2025)

🖼 Interface Snapshots

🧩 Detailed Comparison

🧠 Philosophy & Intended Use

💻 Platform Support

🔐 Privacy & Offline Use

⚙️ Integrations & Extensibility

☁️ Sync & Self-Hosting

Why `tmux` (Alone) Isn’t Enough