Developer's Block

I’m big on this.

I find it efficacious to have an integrated product going as soon as possible, even if it’s a field of stubs.

It’s my experience that I almost never know what the end product will look like, no matter how much upfront planning time I devote, so being able to test and iterate the whole system, as soon as possible, is pretty vital.

It’s also one reason that I like to use test harnesses a lot[0].

[0] https://littlegreenviper.com/testing-harness-vs-unit/

How many times has this happened to me?

You struggle with a feature or a bug, you think about it, you weigh the pros and cons for hours... because you don't want to start something that will set you back. You're tired, but you don't want to go to sleep until you've at least made a decision for tomorrow.

Go to sleep. Now.

Then you wake up knowing immediately what to do. You hardly believe it, because it was so hard to find before you sleep. And you do it. And it works. And you know that sleep was the key.

Particularly the first part. I want to add a new feature, but I want to keep things clean. It needs tests, CI, documentation.

It makes exploring new ideas a bit cumbersome, because code tends to create minor distractions that eat up time. You miss a semicolon, or you forget the order of the arguments to a function you just wrote, do you have to flip to another file. Or the test framework needs an update, but the update breaks something so you have to do some changes. It's not just the time either, it's the context switch from the big picture to the very small details, and then back again.

LLM lets me do "one whole step" at a time. Or that's the positive spin on it. Seen another way, I'm further out from the details, and in most things, you have to hit a bit of a wall to really learn it. For senior devs, I lean towards the first, you've already learned what you're going to learn from fixing imports, you are operating on a higher level.

It had some good stuff in it, the best of which (for me) was: when stuck, write debugging infrastructure.

[1] https://oxide-and-friends.transistor.fm

[2] https://oxide-and-friends.transistor.fm/episodes/coders-bloc...

Edit: punctuation

Two things that help me:

* have a good boilerplate

* ship things that do nothing

i.e. I find it helps to start a project using my good boilerplate then set up builds and releases (so for web projects, put them online) so that the page doesn't look so blank anymore, and I can see my progress in "releases" even if they're just for me/others contributing.

A good defense against this is borrowing stuff from your prior projects, alongside eventually creating templates for the most common stuff.

For example, in new side projects I start, I can borrow the web server (ingress) configuration from the prior ones, same for CI pipelines and a large part of the previous Dockerfiles, sometimes even entire services with all of the annoying setup and configuration stuff already done.

Plus, this way, you have a more or less working baseline and further iteration is entirely up to you - and if you do want to improve things a bunch, then the next time your template will be even better and you'll be able to backport whatever you think everything should have to your other projects as well.

Going with the simplest solutions along the way helps: Bash scripts for triggering builds, CI configuration just calling those, using Docker or similar containers for the environments and builds, your ingress just being Nginx/Caddy/Apache2/..., using PostgreSQL or SQLite and specialized stuff like Redis/Valkey, RabbitMQ, MinIO and so on instead of reinventing the wheel.

Sometimes it's also useful to write utility scripts and even small tools to help with the projects, I bet developers that have been around for decades and are way better than I am have a lot of that stuff, alongside a healthy helping of dotfiles for existing tools to get in the zone while doing the dev work. Although it can also be helpful to go the YAGNI route and customize things as little as possible, like a stock IDE install, not even bothering with the color themes or keybinds or a plethora of plugins - just install and go.

I agree with most of the article, but this part keeps me thinking. Scheduling to contribute later will almost never work. Either I do it now or never. The task is lost in a list of infinitely many tasks. Also, contributing to a dependency (if I understand this correctly) is always something that helps at least two: yourself - doing something good, helping to improve someone’s work, getting something done - and the person who works on the dependency project. The other gets (positive) feedback and knows someone uses their product/software/library

I like extreme cycling, and it helped me solved many problems about development.

When I'm riding my bike and listening to music, especially when freely imagining and designing my product in my mind, I am very relax. Many aspects of my products were designed while I was riding.

Cycling is a great form of exercise. It not only helps you strengthen your body, enjoy the scenery, relax your mind, relieve stress, and adjust yourself, but it can also spark plenty of inspiration. If you’re under heavy pressure or working on a product, I highly recommend you go cycling regularly.

Simplify the mental model of the code, product, etc. Discuss it with someone.

"Ironically" because I usually rewrite almost everything it generates (sans the file and class names, sometimes). But when I describe the idea enough to give Claude some chance of implementing it, I refine it and start planning the high-level implementation. Then the file of LLM slop, even though I have to rewrite most of it, is much less overwhelming than a blank file.

> Take time with learning

But this one in particular stands out. We are being constantly pushed to ship code at faster and faster rates. AI has only hastened the process.

If you want to learn anything new you have to slow it down, push back against all the forces urging you to do more, ship more, make more money.

If you're using AI tools, do the opposite of what everyone else is doing. For every piece of generated code you accept, scrutinize every line, ask clarifying questions, ask for alternate implementations, ask what the tradeoffs are.

Just be curious.

This will be slow, but that's the point.

I start to experiment with coding agents to try some things to make me unstuck. These are cheap to try.

Then, the outcome is either "wow, this can actually work" or "but this is bullshit, and will never work, let me do it myself the right way!"

Win/win.

For solo work, I've found a framework of four learning modes effective: reading, when you are exploring something new, sketching/speccing depending on the detail level you're aiming for, coding only when you might forget things you didn't bother writing down, and relaxing as the fallback state. The key is to be in only one mode at a time and to avoid getting stuck in any single one. Based on nature of the work, you might switch two or three times a day. And always know the next two immediate steps; if you don't, that's your signal to switch. Rinse and repeat.