Learning emacs to the point that the chords are second nature and require no (or very little) thought to produce (aka, fluency).
Using org-mode (other tools work as well, but particularly useful if you're fluent in emacs).
Full-screen apps, or two apps side-by-side. Specifically terminal, or terminal + reference (text, websites, man pages, PDFs). This helps to force focus on the specific task at hand.
My use-cases for org-mode: General project planning/management (personal, mostly); literate programming; notes while reading texts; notes while learning a subject.
Want to learn a new codebase but find reading dozens or hundreds of C and H files to be difficult to track? Slurp them into a massive org file that can spit them all back out using C-v-t (tangle). Then keep breaking the code down into smaller chunks adding notes, moving related sections in separate files closer to each other, etc.
Want to read a book and take notes on it? Half the screen is the PDf, half the screen is emacs. Create a headline per chapter, as you read, take notes. Write out definitions, use > content to create anchors for links like [anchor]. Write out your notes, capture things that you want to follow-up on, page numbers, etc. Each chapter and section gets marked as TODO (or customized) or DONE so you can chart your progress through the text.
Want to understand an RFC and maybe implement it? Put it into an org file, start structuring it, add in source blocks (or, if the RFC has source, turn them into source blocks as well).
===
And then there's GTD. Grok it. Understand that it's not a dogma but a toolkit. The tools exist to free you from the mental burden of tracking activities you need to do by capturing them, prioritizing them, dismissing them as needed, and scheduling them. If you aren't thinking about what's coming up, you can think about what's present.
===
EDIT:
Automate all the things. I write scripts to do a lot of my computer-based tasks. The purpose is to reduce error-rate (if there's an error, the script or the input was wrong, fixing the script fixes the former, adding a check to the input prevents the latter from recurring). It also gets things out of my head. I can literally forget how to do X, Y, and Z (frequent, maybe critical, but unnecessary for me to remember with any precision tasks). This is also useful for migrating a project from largely hand-rolled toward continuous integration/deployment (especially in my office where we don't quite have the infrastructure in place to do that properly or consistently). An example:
We get deliverables from contractors. My script takes that and pairs it with our own software, updating the libraries we link to with the ones they provided. Runs the build script. Constructs our deliverable. Pushes the output to a particular spot. Different parts of that are different scripts with one script to run them all. With a proper CI/CD platform, you could take each of these and put them in as stages triggered off things like git commits.
So now I've got these scripts, we have the git server and build server, I can restructure it all in a way that will run on that. Now I'm out of the loop. Whoever retrieves the contractor's deliverable and pushes it will also trigger the full rebuild of our system. No specific human is critical.
That's a specific work improvement, but the same can be done for many personal computer-based tasks as well. Like how GTD gets your future plans out of your head and into your calendar or whatever, automation gets your processes out of your head so you can focus on the product and inputs of the process and not the process itself.