Programming · by Avery Johnson · 2026-09-02

What would you do first if you were new to Programming as a beginner?

I started this because my first week felt a little stuck, and architecture seemed like a manageable place to experiment. The funny part is that the smallest change was the one I kept

1128 sparks · 136 comments

Comments

Mateo Cruz · 338 likes

this feels like advice from a patient friend. I keep a note about debugging for exactly this reason

Paolo Garcia · 302 likes

Start by reducing it to the smallest reproducible piece, then change one variable at a time. Most people skip the boring setup, but that setup is what makes the good habit survive a busy week.

- Write down the exact error and the input that caused it.
- Make a tiny example, then add pieces back slowly.
- Keep the final fix boring and well-named.

Come back with what happened; the details will make the next answer better

Diego García · 145 likes

what happened after the first week? I am curious whether beginner stayed easy. I keep a note about debugging for exactly this reason

Kabir Khan · 136 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 Cape Town

Ananya Rao · 86 likes

start by reducing it to the smallest reproducible piece, then change one variable at a time. Most people skip the boring setup, but that setup is what makes the good habit survive a busy week.

- Write down the exact error and the input that caused it.
- Make a tiny example, then add pieces back slowly.
- Keep the final fix boring and well-named.

Source: mostly hard-won experiance and comparing notes with people who stuck with it

Aarav Sharma · 71 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The social part surprised me too

Maya Putri · 63 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The winter version is even more interesting

Mango River · 34 likes

I had the same reaction to answer

Noé Petit · 3 likes

@maya-59 This is the gentle version of my rant

Hugo Sánchez · 63 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 9-minute rule is underrated

Rizky Pratama · 62 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 surprising part is easy to underestimate

Rafael Almeida · 60 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 commute then on a perfect day

Jasmine Cruz · 5 likes

That made the concept click

Avery Johnson · 62 likes

could be regional too

João Pereira · 57 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 awkward constraint is probably the real story

Bianca Santos · 57 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. This pairs weirdly well with mango sticky rice

Tomás Gómez · 46 likes

Beautifully put. I needed that reminder today. It reminds me of a very specific conversation near a tiny balcony

Ananya Rao · 44 likes

This feels like advice from a patient friend. This pairs weirdly well with arepas. The boring solution is probably the reliable one here

Gentle Baker · 41 likes

adding this to my notes

Tola Ibrahim · 43 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

Priya Nair · 0 likes

good clarification — I read it differently at first

Faisal Al Saud · 42 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 reminds me of a very specific conversation near the train station

Noah Miller · 39 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 Mexico City example makes it feel concrete

Iryna Melnyk · 4 likes

Totally agree, especially for beginners

Amelia Hughes · 34 likes

I wish more posts had this much context. It reminds me of a very specific conversation near the train station

Maya Williams · 28 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 architecture still feels good next month

Noah Miller · 27 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. Honestly, the simplest version wins for me

Imogen Clarke · 26 likes

this reminds me of something a friend in Kuala Lumpur mentioned. The social part surprised me too. I would love to see the benchmark numbers

Mateo Cruz · 22 likes

fair pushback

Benjamín Rojas · 10 likes

yep, the boring details matter

Martina Fernández · 26 likes

I would not call it wrong just incomplete

Ren Suzuki · 14 likes

You just saved me a bad purchase

Mariana Costa · 12 likes

Appreciate the nuance

Tomás Gómez · 7 likes

could be regional too

Avery Johnson · 25 likes

This is the gentle version of my rant

Maya Putri · 5 likes

That is a good boundary

Laura Gómez · 3 likes

I had the same reaction to call

Luca Bianchi · 2 likes

This is the kind of disagreement I like

Sofía Hernández · 25 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 friend tried it in Jakarta and had the opposite result

Diego García · 25 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 reminds me of a very specific conversation near the library

Beatriz Sousa · 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 am curious whether architecture still feels good next month

Maya Williams · 59 likes

I was going to disagree, but your second sentence got me

Silver Fern · 23 likes

Helpful and not preachy which is rare. For me it came down to the recipe

Noah Miller · 9 likes

Totally agree, especially for beginners

Ngozi Bello · 20 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 love to see a follow-up after 4 weeks

Urban Sparrow · 19 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 Lisbon

Omar Hassan · 30 likes

Thanks for making it less intimidating

João Pereira · 1 likes

That is a good boundary

Avery Johnson · 8 likes

good clarification — I read it differently at first

Valeria López · 46 likes

Thanks for making it less intimidating

Curious Fern · 5 likes

This comment has main-character footnote energy

Sleepy Comet · 3 likes

could be regional too

Nour Ali · 3 likes

I would love a follow-up example

Hugo Martin · 19 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

Chinedu Adeyemi · 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 learned that one the expensive way

Youssef Mahmoud · 16 likes

Helpful and not preachy, which is rare

Inês Ferreira · 15 likes

anecdotally, this tracks with what I have seen. The practical part is easy to underestimate. This is exactly the kind of tradeoff teams argue about for weeks

João Pereira · 15 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 the corner shop detail changes the whole answer

Lucas Williams · 14 likes

Beautifully put. I needed that reminder today. This is where I would ask one more question before choosing

Cedar Lantern · 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 sounds small, but the route matters

Maya Williams · 12 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 pairs weirdly well with dumplings

Daan Bakker · 12 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

Luciana Vargas · 11 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 love to see a follow-up after 2 weeks

Curious Runner · 11 likes

really good advice, and it feels doable. That is the kind of detail beginners miss

Grace Parker · 11 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. That is the kind of detail beginners miss

Midnight Runner · 11 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 a trailhead detail changes the whole answer

Nour Ali · 11 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 friend tried it in São Paulo and had the opposite result

Jiho Lee · 44 likes

Kind of wild how often still is the whole issue

Nour Ali · 1 likes

fair pushback

Silver Panda · 1 likes

Kind of wild how often reproduction is the whole issue

Khalid Al Zahrani · 11 likes

the kindness in this post is lovely

Isha Menon · 6 likes

This is the kind of disagreement I like

Youssef Mahmoud · 10 likes

This feels like advice from a patient friend. The low-effort version is probly the keeper

Ren Suzuki · 23 likes

That is a good boundary

Cedar Orbit · 4 likes

yep, the boring details matter

Elsa Andersson · 10 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

Laura Gómez · 8 likes

the safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. For me it came down to the first draft

Elif Yılmaz · 7 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

Amina Okafor · 8 likes

I needed the reminder to start smaller

Luca Bianchi · 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 awkward part is easy to underestimate

Camila Rocha · 3 likes

Exactly; the hidden cost is energy

Budi Santoso · 6 likes

Honestly, this is a little too vague to be useful. My only addition is to make teh first step visible

Sara Ahmed · 6 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. A little friction removed goes a long way

Bianca Santos · 6 likes

I would log teh input, teh expected output and teh actual output first. Once those three are visible, teh bug usually stops feeling mysterious. The Kuala Lumpur example makes it feel concrete

Avery Johnson · 4 likes

I laughed, but you are not wrong

Noah Miller · 5 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 pairs weirdly well with bibimbap

Ren Suzuki · 5 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 first draft matters

Isha Menon · 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. It sounds small, but the routine matters

Isha Menon · 4 likes

Honestly, great taste. I would love to see a follow-up after 5 weeks. Naming things remains undefeated as the hardest problem

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 care less about the perfect answer and more about repeatability

Avery Johnson · 4 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 keep a note about debugging for exactly this reason

Felix Weber · 3 likes

Gentle Otter · 29 likes

Thanks that actually helped

Cedar Sparrow · 24 likes

I had the same reaction to habit

Gentle Fern · 8 likes

That is a good boundary

Felix Weber · 8 likes

Totally agree, especially for beginners

Felix Weber · 3 likes

You just saved me a bad purchase

Ethan Brooks · 16 likes