How to Build a Personal Task System That Actually Sticks — GTD for Developers
W
Writer
Published: 16 Jun 2026
12 min read
Getting Things Done adapted for software engineers — inbox capture, weekly review, project vs next-action distinction, and complete implementation templates for both Obsidian and Notion.
Why Developer Task Systems Fail
Most developer productivity systems collapse within two weeks. The Trello board gets stale, the Notion database becomes a to-do graveyard, the sticky notes multiply. It is not a discipline problem — it is a design problem. The system asks too much at the wrong moments (during deep work) and too little at the right moments (during planning).
David Allen's Getting Things Done (GTD) is the most battle-tested personal productivity methodology ever created. Published in 2001, it has been adopted by everyone from executives to surgeons to software engineers. This guide adapts the core GTD principles specifically for developers — with implementation templates for both Obsidian and Notion, and a weekly review ritual you will actually complete.
The Core Problem GTD Solves
Your brain is terrible at storage but excellent at processing. Every uncaptured task — the PR you need to review, the client email you must reply to, the bug you noticed but did not file — sits in your working memory consuming CPU cycles. GTD calls this 'open loops'. The anxiety you feel on Sunday evening is not laziness; it is the weight of all your open loops.
GTD closes open loops by externalising everything into a trusted system. Once your brain trusts that nothing will be forgotten, it stops background-processing your task list — and you get that cognitive RAM back for actual thinking.
The Five GTD Steps (Developer Edition)
1
Capture — Get It Out of Your Head: Every task, idea, bug, and obligation goes into one inbox immediately. Not later, not after the meeting — now. Use a single capture tool: a physical notebook, Apple Notes, or a dedicated 'Inbox' in your task app. The rule: one inbox, always emptied during weekly review.
2
Clarify — Define the Next Physical Action: For each item in your inbox, ask: what is the very next physical action required? Not 'work on auth bug' — but 'open auth.ts, reproduce the null pointer on line 47'. Vague tasks never get done; specific actions do. If something takes under 2 minutes, do it immediately.
3
Organise — Put It Where It Belongs: Sorted items go into one of four buckets: Next Actions (do this week), Projects (multi-step outcomes), Someday/Maybe (ideas with no commitment), or Reference (information you might need). Nothing lives in your inbox after organising.
4
Reflect — Weekly Review: Every Sunday or Monday morning, spend 30 minutes: empty your inbox, review all projects for missing next actions, review your Someday/Maybe list for anything to promote, and plan your top 3 outcomes for the week. This is the heartbeat of the system — skip it and the whole thing breaks.
5
Engage — Choose What to Work On: With a clean system, choosing what to work on becomes easy. Filter your Next Actions list by context (at computer, in meeting, low energy) and pick the highest-priority item that fits your current time and energy. No more decision paralysis.
The GTD Vocabulary Every Developer Needs
Projects vs Tasks
In GTD, a project is any outcome that requires more than one action. 'Implement OAuth login' is a project. 'Open oauth.ts and add Google provider config' is a task. Most developers confuse the two — they put 'Implement OAuth login' on their task list and then stare at it, paralysed, because it is not actionable. Every project must have at least one clearly defined next action.
The Two-Minute Rule
If an action will take less than two minutes to complete, do it immediately during your clarify step — never put it in your system. Replying to a short Slack message, filing a GitHub issue, or adding a comment to a PR all qualify. The overhead of tracking it costs more than just doing it.
Contexts
Contexts tag tasks by where or what you need to do them. Traditional GTD used physical contexts (@office, @phone, @errands). For developers, energy-based contexts are more useful — your best thinking happens at different times of day, and context switching between deep and shallow work is expensive.
Someday/Maybe is the most underused GTD list. It is where you put ideas you want to explore but are not committing to now: that side project, the conference you might speak at, the library you want to experiment with. Without Someday/Maybe, these ideas either get forgotten or clutter your active project list and create guilt.
Implementing GTD in Obsidian
Obsidian is ideal for GTD because its plain text files and flexible linking let you build exactly the structure you need with no imposed schema. Here is a minimal, battle-tested folder structure:
# Inbox> Capture everything here. Process during weekly review.## Unprocessed- [ ] Reply to Arjun about API rate limits
- [ ] Auth bug reproduced in staging — null pointer on login
- [ ] Idea: write blog post about Postgres JSONB indexing
- [ ] Check if Cloudflare R2 is cheaper than S3 for current usage
- [ ] Book dentist appointment
<!-- Add new items above this line during the week -->
Project Template
markdown
01-Projects/_project-template.md
# Project Name**Outcome:** [What does done look like?]
**Deadline:** [Date or 'no deadline']
**Status:** Active | On Hold | Waiting
## Next Actions- [ ] @deep — [first physical action]
- [ ] @code — [second action]
## Waiting For- [ ] [Person] — [what you are waiting on] — [date sent]
## Notes
[Architecture decisions, links, context]
## Done- [x] Completed action with date
Dataview Query for Weekly Dashboard
Install the Dataview plugin to create a live dashboard that pulls all uncompleted tasks across your vault:
markdown
Weekly Dashboard (Dataview)
```dataview
TASK
WHERE !completed
AND file.path contains "02-Next-Actions"
GROUP BY file.name
SORT file.name ASC
``````dataview
TASK
WHERE !completed
AND file.path contains "01-Projects"
AND contains(text, "@waiting")
SORT file.mtime DESC
```
Implementing GTD in Notion
Notion's database features make it well-suited for GTD — filter views act as virtual context lists, and relations link projects to their next actions. Here is the minimal database setup:
Database
Key Properties
Purpose
Tasks
Name, Context, Project (relation), Status, Energy, Date
All next actions
Projects
Name, Outcome, Status, Tasks (relation), Deadline
Multi-step outcomes
Inbox
Name, Processed (checkbox), Date
Capture only
Someday/Maybe
Name, Category, Date Added
Parked ideas
Notion Views to Create
Today — filter: Status=Next Action, Date=Today, sorted by Energy desc
@waiting — filter: Status=Waiting, sorted by Date asc
All Projects — filter: Status≠Done, sorted by Deadline asc
Weekly Review — filter: Processed=false (Inbox) + all active projects without next actions
The 'Projects Without Next Actions' View
The most powerful Notion view you can create is filtered to show projects that have no linked tasks with Status=Next Action. This is your stalled project detector — during weekly review, every project on this list needs a next action added before you close your laptop.
The Weekly Review Protocol (30 Minutes)
The weekly review is non-negotiable. Without it, the system degrades — stale tasks pile up, projects lose their next actions, and the inbox overflows. Block Sunday 6–7pm or Monday 8–8:30am. Put it in your calendar as a recurring event with a reminder.
1
Clear Physical and Digital Inboxes (5 min): Process every item in your capture inbox, email inbox (to Inbox Zero), Slack unreads, and browser tabs. Each item gets clarified and moved to the right list, or deleted.
2
Review All Active Projects (10 min): Open every project. Ask: is this still relevant? Does it have a clear next action? Is anything blocked? Add a next action to anything stalled. Archive projects that are done or abandoned.
3
Review @waiting List (3 min): For every item you are waiting on, check if you need to send a follow-up. A 'waiting' item with no follow-up after 5 days should become an active task: 'Chase [person] about [thing]'.
4
Review Someday/Maybe (3 min): Scan the list. Is anything now ready to become an active project? Is anything clearly dead and should be deleted? Keep this list honest — a graveyard of never-started ideas is demotivating.
5
Plan the Week's Top 3 Outcomes (5 min): Write three sentences starting with 'By Friday, I will have...' These are not task lists — they are outcome statements. They become your decision filter when choosing tasks each day: does this work move me toward one of my three outcomes?
6
Set Tomorrow's First Task (2 min): Before closing, pick the single most important @deep task for Monday morning. Put it as a calendar block for 9am. Starting the week knowing exactly what you are doing first eliminates Sunday-evening anxiety.
GTD for Teams vs Solo Developers
GTD is a personal system — it manages your own commitments, not a team's. Many developers make the mistake of trying to enforce GTD on their team. Do not. For team coordination, use Linear or Jira. Use GTD to manage your personal inputs from those tools: when a ticket is assigned to you, capture it into your system with a defined next action.
Scenario
Use GTD?
Use Team Tool?
Your own tasks and commitments
Yes
No
Sprint planning with team
No
Yes (Linear/Jira)
Personal learning goals
Yes
No
Shared project milestones
No
Yes
Client deliverables you own
Yes
Mirror in team tool
Waiting on a colleague
Yes (@waiting list)
Also track in team tool
Common GTD Mistakes and How to Avoid Them
Mistake: Multiple inboxes (email, Slack, Notes, Jira — all unchecked). Fix: Pick one capture tool. Everything else feeds into it during review.
Mistake: Tasks that are really projects ('Build dashboard', 'Refactor auth'). Fix: Any task that takes more than one sitting is a project. Break it down.
Mistake: Skipping the weekly review for 2 weeks. Fix: Set a hard calendar block with a 30-minute reminder. Miss it once, the system breaks. Miss it twice, you abandon it.
Mistake: Overly elaborate setup. Fix: Start with just inbox + next actions list + weekly review. Add complexity only when you feel the need.
Mistake: Using GTD for team deliverables. Fix: GTD tracks your personal commitments. Team commitments live in the team tool and create entries in your GTD system.
Frequently Asked Questions
How long does it take to set up GTD?
The initial setup takes 2–4 hours: building your folder or database structure, doing a 'mind sweep' to capture every open loop in your head, and clarifying each item. After that, the daily overhead is 5–10 minutes of capture and the 30-minute weekly review.
Should I use GTD with pen and paper or digitally?
Either works — David Allen himself uses paper for some lists. The key is that your system is always with you (so you can capture immediately) and always trusted (so your brain stops holding backups). For developers, Obsidian or Notion on all devices satisfies both requirements.
What is the best GTD app in 2026?
OmniFocus (Mac/iOS, ₹5,000 one-time) is purpose-built for GTD and the most powerful. Todoist (₹300/month) has excellent GTD support with filters and labels. For developers who prefer open formats, Obsidian with the Tasks plugin is the best free option.
How do I handle GitHub notifications in GTD?
Set GitHub notifications to batch mode (daily digest email rather than real-time). During your morning admin block, process notifications: PRs you are reviewing become @code tasks, issues you need to respond to become @admin tasks, anything you are waiting on goes on the @waiting list.
My job is fully reactive — can GTD still work?
Yes. GTD is not about planning your entire day upfront — it is about maintaining a trusted list so that when you do have 20 minutes of non-reactive time, you know exactly what to work on. Even highly interrupt-driven developers benefit from the capture habit and weekly review.
Key Takeaways
GTD's core insight: your brain is for processing, not storage — externalise everything into a trusted system
The 2-minute rule eliminates small-task procrastination: if it takes under 2 minutes, do it now, never schedule it
Energy-based contexts (@deep, @code, @admin) work better for developers than location-based contexts
Every project must have at least one next physical action — projects without next actions are stalled projects
The weekly review is the heartbeat of the system — skip it twice and the system collapses
Obsidian (free, local) and Notion (free tier) both support complete GTD implementations with the templates in this guide
