Comments
Ren Suzuki · 70 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. It reminds me of a very specific conversation near a coworking table.
Curious Mango · 34 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. That is the kind of detail beginners miss.
Chloe Davis · 33 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I care less about the perfect answer and more about repeatability.
Zeynep Demir · 24 likes
This is useful for some cases, but terrible advice if the stakes are high. This would have saved me a lot of trial and error.
Ananya Rao · 24 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I learned that one the expensive way.
Mariam Said · 24 likes
Honestly, great taste. It reminds me of a very specific conversation near the library.
Mia Anderson · 23 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I used to overcomplicate this constantly.
Nicolás Díaz · 1 likes
@mia-67 The Tuesday test is undefeated.
Curious Panda · 2 likes
Small caveat: context changes the answer a lot.
[deleted] · 2 likes
Thanks, that actually helped.
Quiet Fern · 23 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I noticed the same thing in Istanbul.
Ngozi Bello · 23 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. My only addition is to make the first step visible.
Inês Ferreira · 23 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I would love to see a follow-up after 8 weeks.
Sara Ahmed · 21 likes
I wish more posts had this much context.
Grace Parker · 6 likes
That is fair, but I still worry about maintenance.
Kabir Khan · 18 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I would write it down before changing anything else.
Lena Müller · 18 likes
Agree completely. The simple version is underrated. The beautiful constraint is probably the real story.
Oussama Alaoui · 17 likes
That last line is excellent. The 9-minute rule is underrated. A small test case would make this easier to trust.
Aarav Sharma · 7 likes
I needed the reminder to start smaller.
Daniel Kiptoo · 16 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I am curious whether tools still feels good next month.
Grace Parker · 1 likes
I was going to disagree, but your second sentence got me.
Daniel Kiptoo · 4 likes
@atlasMender4 I had the same reaction to disagree.
[deleted] · 3 likes
I am stealing that phrase.
Curious Orbit · 2 likes
That sounds great until you add children/pets/deadlines.
Aoi Ito · 16 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I noticed the same thing in São Paulo.
Maja Wiśniewska · 15 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. The surprising part is easy to underestimate.
Haruto Sato · 15 likes
My first thought was cost, then time, then whether I would remember to do it. The surprising part is easy to underestimate.
Silver Fern · 15 likes
There is a hidden assumption here that not everyone shares.
Maya Putri · 15 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. It sounds small, but the playlist matters.
Camila Rocha · 14 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. It reminds me of a very specific conversation near a family dinner.
Lucas Dubois · 13 likes
I had a similar experience, but my problem was consistency rather than motivation. I would test it for 7 days before deciding.
Curious Orbit · 11 likes
Fair point, but I had the opposite experience. This pairs weirdly well with idli.
Isha Menon · 1 likes
Exactly; the hidden cost is energy.
Amina Okafor · 10 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I would love to see a follow-up after 3 weeks.
[deleted] · 6 likes
The best answer in the thread, honestly.
Mateo Cruz · 9 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I would test it for 6 days before deciding.
Rafael Almeida · 2 likes
Small caveat: context changes the answer a lot.
Avery Johnson · 9 likes
The vibe here is immaculate. That is where the boring checklist helps.
Niamh Byrne · 6 likes
I had the same reaction to immaculate.
Hugo Martin · 9 likes
I get the appeal, though I would be careful calling it the best option. I keep a note about architecture for exactly this reason. I would love to see the benchmark numbers.
Benjamín Rojas · 0 likes
@hugomakes Totally agree, especially for beginners.
Ananya Rao · 9 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. My friend tried it in Cape Town and had the opposite result.
Rizky Pratama · 21 likes
@sparrowRunner3 The best answer in the thread, honestly.
Haruto Sato · 9 likes
Anecdotally, this tracks with what I have seen. I care less about the perfect answer and more about repeatability.
Paolo Garcia · 9 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. This is more useful on a tired winter than on a perfect day.
Kabir Khan · 9 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I would write it down before changing anything else.
Lucía García · 8 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. The winter version is even more interesting.
Curious Atlas · 8 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. My only addition is to make the first step visible.
Ananya Rao · 8 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. The weekend version is even more interesting.
Paolo Garcia · 7 likes
Love the tiny experiment energy. The Monday morning version is even more interesting.
Noah Miller · 0 likes
I needed the reminder to start smaller.
Nima Ahmadi · 7 likes
I would not call it wrong, just incomplete. The ambitious part is easy to underestimate.
Ayesha Khan · 7 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. The Dublin example makes it feel concrete.
Felix Weber · 17 likes
@ayesha-29 I am stealing that phrase.
Emir Kaya · 7 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. The gentle constraint is probably the real story.
Miguel Santos · 7 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I am curious whether java still feels good next month.
Sleepy River · 2 likes
That sounds great until you add children/pets/deadlines.
Theo Bennett · 7 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The 2-minute rule is underrated.
Kabir Khan · 7 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I used to overcomplicate this constantly.
Grace Parker · 6 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I would test it for 8 days before deciding.
Hugo Sánchez · 6 likes
I found this disappointing because it skips the hardest part.
Cozy Noodle · 5 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. A little friction removed goes a long way.
Urban Panda · 4 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I am curious whether learning still feels good next month.
Quiet Coder · 4 likes
I do not have a strong take, but the know detail is useful. The Cairo example makes it feel concrete. Naming things remains undefeated as the hardest problem.
Noah Miller · 4 likes
Great point, especially the part about tweaking. I would test it for 3 days before deciding.
Felix Weber · 4 likes
This is one of those ideas that looks great online and falls apart on Tuesday. For me it came down to the prototype.
João Pereira · 4 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. A little friction removed goes a long way.
Maja Wiśniewska · 4 likes
The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. This would have saved me a lot of trial and error.
Imogen Clarke · 4 likes
The kindness in this post is lovely. I would love to see a follow-up after 10 weeks.
Nicolás Díaz · 4 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I noticed the same thing in Manila.
Huy Le · 4 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. This is where I would ask one more question before choosing.
Irene López · 3 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I would love to see a follow-up after 5 weeks.
Bianca Santos · 3 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. Honestly, the simplest version wins for me.
Nour Ali · 3 likes
This is genuinely helpful, thanks for writing it out. I would write it down before changing anything else.
Grace Parker · 3 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I learned that one the expensive way.
Imogen Clarke · 3 likes
Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I learned that one the expensive way.
Marco Conti · 3 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I care less about the perfect answer and more about repeatability.
Aarav Sharma · 3 likes
I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. The 3-minute rule is underrated.