⏱️ Lectura: 10 min
A software engineer needed a 15 minute timer and had to block every possible distraction on his computer just to write about a problem that follows him daily: it keeps getting harder to stay on a single task. The case, documented on the personal blog of the developer who goes by Glyphack, sums up a complaint that has circulated among programmers for months: between the phone, browser tabs, and an open chat with an LLM, fragmented attention has become the norm.
📑 En este artículo
The author isn’t looking to work marathon days. He just wants the hour he spends coding or writing to actually be one single activity, not ten six minute interruptions.
TL;DR
- Developer Glyphack needs a 15 minute timer and blocked distractions to write with real focus.
- He calculates he now manages barely 1 hour of sustained attention per day, compared to full days of study and open source work before.
- He identifies 3 distraction triggers: jumping from link to link, checking the phone while waiting for something, and getting up when facing a hard problem.
- In an earlier time tracking experiment, he measured 8 hours a week spent just chatting on Slack.
- He points to LLMs as a new source of distraction: he delegates a task and keeps thinking about it while waiting for the response.
- Since 2015 he avoids keeping his phone charger near the bed to curb nighttime scrolling.
- He proposes measuring your own time with time tracking before trying to fix focus blindly.
What happened
The essay “It’s getting harder to focus every day” appeared on Glyphack’s personal blog and describes a pattern the author documented about himself. For years, while studying, working, and contributing to open source projects at the same time, he managed to sustain the focus needed to make progress on all three fronts. Today, he says, he settles for one hour of concentrated work per day.
The author isn’t describing an isolated case of procrastination: he lists concrete triggers. Looking up a link related to what he’s doing ends in a chain of clicks toward unrelated content. Waiting for a response (from a coworker, a build, an LLM) is enough time to open the browser and lose the thread. And faced with a problem that requires ten minutes of thinking without solving it right away, the body finds an excuse: getting up for water, checking the phone, even making the bed.
The author draws a comparison between university and work. In college, he says, someone who copied assignments without understanding the topic was exposed the moment anyone asked a specific question: a good grade didn’t mean much on its own. In his first job he found something different: people who barely paid real attention to their work were considered just as successful, while most of their days were split between meetings and internal chat.
Context and history
The author traces the origin of the problem back to 2015, when he decided never to keep a charger near his bed. At the time, the diagnosis was already clear to him: apps designed to hold attention (what’s now known as the attention economy) captured hours from a teenager without him noticing. On the computer, though, usage was different: reading, coding, or playing chess, intentional activities, not passive browsing.
That balance broke when he discovered sites like Hackernoon and Medium, the first source of content he consumed out of boredom in front of the computer. In their early years those sites had quality content (the author mentions finding channels there that motivated him to code more), but over time, he says, they filled up with filler articles optimized for monetization. Hacker News, YouTube, and more recently LLM based assistants took over that space.
Technical details: how LLMs deepen fragmented attention
The author identifies a specific pattern in AI assistants that didn’t exist with previous tools. When he delegates a task to an LLM and moves on to another activity while waiting for the response, he can’t disconnect from the first one: he keeps thinking about what the model is doing with that task. The result is that neither activity gets full attention.
The author sums it up this way: the brain finds a way to avoid uncomfortable situations, like boredom or difficult work, and an unfinished task delegated to an LLM is the perfect excuse to divert attention elsewhere.
There’s a second, inverse pattern: instead of starting to work, he opens a chat with the LLM to discuss an idea and stays there, in research mode, for hours, without writing a single line of code. Neither mode (delegating and waiting, or conversing without executing) amounts to real focused work.
The diagram below sums up the interactive waiting cycle the author describes:
sequenceDiagram
participant D as Developer
participant L as LLM
D->>L: delegates a task
Note over D: keeps thinking about the delegated task
D->>D: tries to start something else
L-->>D: responds minutes later
D->>D: corrects and validates the response
The alternative the author proposes is to treat the LLM as a truly asynchronous task: ask for something the model can resolve end to end without supervision, close the chat, and don’t reopen it until the original (human) task is done.
💡 Tip: if you’re going to delegate a task to an LLM, write out the full request, close the tab or terminal, and set a timer to check the response only once you’ve finished your own block of work.
How to start: reclaiming blocks of deep work
Blocking distractions at the operating system level is more effective than relying on willpower. The hosts file exists on Windows, macOS, and Linux, and lets you redirect a domain to 127.0.0.1 so the browser can’t resolve it.
On Linux and macOS it’s edited with admin permissions:
sudo -- sh -c "echo '127.0.0.1 reddit.com' >> /etc/hosts"
sudo -- sh -c "echo '127.0.0.1 www.reddit.com' >> /etc/hosts"On Windows, the same file lives at C:\Windows\System32\drivers\etc\hosts and is edited from PowerShell as administrator:
Add-Content -Path C:\Windows\System32\drivers\etc\hosts -Value "127.0.0.1 reddit.com"These lines are enough to stop that domain from loading in any browser on the machine. The following script automates the temporary block and reverts it on its own, more practical than editing the file by hand every time:
#!/usr/bin/env bash
# focus.sh 25 -> blocks distractions for 25 minutes
MINUTES=${1:-25}
SITES=("reddit.com" "www.reddit.com" "twitter.com" "x.com" "news.ycombinator.com")
for site in "${SITES[@]}"; do
echo "127.0.0.1 $site" | sudo tee -a /etc/hosts > /dev/null
done
echo "Block active for $MINUTES minutes."
sleep "$((MINUTES * 60))"
for site in "${SITES[@]}"; do
sudo sed -i.bak "/127.0.0.1 $site/d" /etc/hosts
done
echo "Block finished."Saved as focus.sh and run with bash focus.sh 25, the script adds the entries at the start, sleeps the process for the given minutes, and removes those lines from the hosts file when it’s done. To confirm the block is active while it runs, cat /etc/hosts | grep reddit is enough: if the line with 127.0.0.1 shows up, the domain won’t resolve until the script reverts it.
Before blocking anything, it’s worth measuring where the time actually goes. Tools like RescueTime, Toggl Track, or a simple manual log in a text file help confirm, with your own data, how many times per hour you switch tabs or tasks. The author arrived at the figure of 8 hours a week on Slack through that same exercise, not a hunch.
Impact and analysis
Glyphack’s case isn’t unique, but it puts into words something many developers report anecdotally: fragmented attention has become the default state of technical work, not the exception. The author previously measured his real time at work and found he’d spent 8 hours in a week just chatting on Slack, half of a full workday.
Not all techniques for reclaiming focus work equally well depending on the type of task:
| Technique | How it works | Advantage | Limitation |
|---|---|---|---|
| Site blocking (hosts file) | Redirects distracting domains to 127.0.0.1 | Free, works at the OS level | Reverting it must be automated or done by hand |
| Pomodoro (25/5) | Short blocks with fixed breaks | Easy to start, low commitment | Can interrupt right when flow appears |
| Long timeboxing (90+ min) | One long block without checking messages | Allows entering real deep work | Requires negotiating disconnection with the team |
| Delegating to an LLM asynchronously | The full task is requested and the chat is closed until it’s done | Avoids the interactive waiting cycle described above | Only works if the task doesn’t need mid-course correction |
📌 Note: the author clarifies that his goal isn’t to maximize work hours, but to make sure each hour spent coding, learning, or writing is a single activity rather than a mix of ten short interruptions.
What’s next
The author doesn’t offer a closed solution: he describes the problem as something he’s still trying to undo, not a habit already fixed. What is clear from his account is the direction: measure your own time before trying to fix it blindly, treat LLMs as asynchronous delegation instead of interactive chat, and protect long blocks without open messaging to shrink day to day fragmented attention.
If this discussion keeps repeating in programmer forums like Hacker News and Reddit over the coming months, more tools specifically designed for the distraction pattern that AI assistants create, not just for phones or social media, are likely to appear.
📖 Summary on Telegram: View summary
Try it yourself: save the focus.sh script above, run bash focus.sh 25 before your next hard task, and measure how long it takes you to get distracted this time.
Frequently Asked Questions
What is fragmented attention?
It’s the pattern of jumping between tasks without completing any of them with real focus, alternating work, messages, and passive content in cycles of a few minutes.
Why can delegating a task to an LLM distract more instead of less?
Because in interactive chat mode the developer keeps thinking about the delegated task while waiting for the response, never fully disconnecting to attend to something else.
Does blocking sites with the hosts file actually work?
Yes, because it acts at the operating system level and doesn’t depend on a browser extension staying active or on willpower to avoid disabling it.
What’s the difference between using an LLM synchronously versus asynchronously?
In synchronous use the developer waits for the response in real time and ends up with divided attention; in asynchronous use the full task is handed off and picked back up only once the model has finished.
Is the problem only about LLMs?
No: the author documents the same pattern since 2015 with the phone, and even earlier with forums and social media; LLMs are just the most recent layer on top of an older problem.
References
- glyphack.com: the author’s original essay on fragmented attention and distraction while coding.
- en.wikipedia.org: context on the attention economy and how platforms compete for users’ time.
- en.wikipedia.org: author of “Deep Work,” a framework cited in discussions about deep work and focus.
- news.ycombinator.com: community where recurring developer discussions on productivity and distraction take place.
📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion
Imagen destacada: Foto de Vitaly Gariev en Unsplash
0 Comments