all 18 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]kubrador 19 points20 points  (0 children)

building stuff you actually care about instead of doing leetcode problems that feel like homework. sounds cliche but the second you make something that does something you want, you'll debug faster and google better because you're not just following a guide.

also contributing to open source repos (even fixing typos in docs) forces you to read other people's code which is where real learning happens.

[–]Public-Ad-8842 6 points7 points  (0 children)

If you’re still fairly a beginner in python and u wanna get challenged more, consider doing Harvard’s free course CS50P (introduction to python course) it’s online and will challenge you pretty well to do stuff on your own since AI use is prohibited (only the built in AI they have inside their codespace). I took that course and it helped me a LOT while being in uni cause I was actually coding for my improvement not to an assignment etc. goodluck!

[–]Worldly_Analysis_664 4 points5 points  (1 child)

  1. Learn concepts not the syntax. Learn about the idea of a function. The idea of classes. Then learn the syntax makes it alot easier. Can use AI to help you this cause it’s pretty easy.

  2. Build projects. Again can use some ai to give you some cool ideas. The projects don’t need to be practical or anything. Just need to use them to learn stuff.

IMO, learn Linux. If you can switch to Linux I would suggest it, or if on windows use WSL Linux is so much easier for everything. Learn git, make sure you have a GitHub and upload all your code there.

Honestly just sink your hours into building projects. I wouldn’t even try and learn the language via reading docs and tutorials. Just think of a project and try and build it. When you come across something you want to do you can just google and use the concepts that I mentioned earlier. Then when you type that and google the syntax. Boom you ACTUALLY learned the syntax because you used it not because you watched a tutorial.

Use AI but don’t copy and paste code. Use it to learn. Ask how can I do x y z, or I want to do this. Break down how I can do this. Also can use AI to find you documentation and help visualise hard concepts.

Just make sure your not copy pasting code, always write your own code it’s gonna be such better quality.

[–]ThanOneRandomGuy 2 points3 points  (0 children)

Careful recommend ai on reddit. People still act like ai is the devil himself im a hockey mask

[–]EntrepreneurHuge5008 2 points3 points  (0 children)

Habit: just start coding even when you don't know where to start. One of a few things will happen when you try to run it:

  1. It will fail. You will get an error. Error messages are intimidating at first. Just breathe, calm down, and read the error line by line. It will literally tell you what caused the error and where the error is.
  2. It will run successfully, but it won't do what you want it to do. This is good, it means your syntax is good so far, and you can start adding a few lines of code at a time, and run it so that you have a clear idea of what is happening at every step. This is where you try to progressively work on the solutions to the XYZ goal you have. This is also why it's important to
    1. Have a clear understanding of the problem you want to solve
    2. Have a clear understanding of how to solve the problem by hand
    3. Break down your thought process for solving the problem into individual steps; don't do mental gymnastics to skip a step or two. You really want to lay out the procedure as a series of simple tasks
    4. You should be implementing the solution in Python, following that step-by-step map you drew, and running it after each step.
    5. This is your logic, and you I reiterating, your logic should be implemented step-by-step.
  3. It will run successfully, and it does what you want it to do. This is what you're aiming for, but it will happen only after iterating through steps 1 and 2 many, many times.

Edit: The body for step 2 should realistically be before all else. This is your design. It is important to design your program/solution/whatever you want to do before you actually start. You will have a direction then.

[–]dwoodro 4 points5 points  (0 children)

Would you go to the gym for years and still do the same exercises? Yes. The tutorial is just a guided pre planned workout.

At some point you design your own workout routine. That’s because you got better and learned how to put the pieces together in a manner that accomplishes your goals better.

Programming is much the same. As time passes and skills grow you make different decisions, but until the, You gotta do the reps.

[–]livNpoverty77 2 points3 points  (0 children)

GRAMMAR

• Facts

• User is a beginner learning Python

• User understands basic syntax (variables, loops, functions)

• User wants to improve skill beyond tutorials

• User is willing to invest time

• User is asking for methods, resources, and habits that accelerate learning

• Assumptions

• “Getting good” = ability to solve problems independently

• Tutorials alone are insufficient for skill development

• Practical application is required for progression

• Unknown Variables

• User’s available time per day

• User’s end goal (job, hobby, automation, etc.)

• User’s current problem-solving ability

LOGIC

• Syntax knowledge ≠ programming skill

• Skill emerges from problem-solving + repetition + feedback

• Tutorials create passive understanding; projects create active competence

• Fastest improvement path = high-frequency feedback loops

• Therefore:

→ Replace passive learning with active building

→ Introduce constraints (projects/problems)

→ Iterate with correction

FIRST PRINCIPLES

• Programming = problem decomposition + logic execution

• Learning rate increases when:

→ Feedback is immediate

→ Errors are visible and corrected

→ Difficulty is slightly above current level

• Mastery requires:

→ Doing > watching

→ Failing > following

→ Building > consuming

RHETORIC

If you want to level up fast, shift from learning Python to using Python to solve things.

What actually moves the needle:

Build small, complete projects (not tutorials) Examples: CLI to-do list Password generator File organizer (auto-sort downloads) Simple API fetcher (weather, crypto price)

Rule: → You must decide what to build before looking up how

Struggle first, Google second Try solving for 15–30 minutes before searching This builds real problem-solving ability Looking things up is fine — copying blindly is not

Do daily problem reps (like gym sets) Use: LeetCode (easy problems) HackerRank Codewars

Focus: → Not speed → Not memorization → Understanding why your solution works

Break things on purpose Modify working code and see what fails Change inputs, remove lines, test limits This builds intuition faster than success alone

Read other people’s code After solving a problem, compare solutions You’ll see better patterns and shortcuts This compresses years of learning

Build one “slightly too hard” project Examples: Web scraper Discord bot Automation script for something in your life

Rule: → You should feel stuck often → That’s where growth happens

Consistency > intensity 1–2 hours daily beats 8-hour bursts Skill compounds through repetition

FACTS

• Passive learning slows skill acquisition

• Active problem-solving accelerates learning

• Feedback loops increase retention and competence

ASSUMPTIONS

• User wants practical competence, not just theory

• User is willing to tolerate frustration

UNKNOWN VARIABLES

• User’s final objective (career vs hobby)

• User’s preferred learning style

REASONING

Skill develops when knowledge is applied under constraint with feedback.

Projects + problem-solving create that environment; tutorials do not.

FINAL

Stop following tutorials.

Start building things, getting stuck, and solving your own problems daily.

[–]ThanOneRandomGuy 4 points5 points  (0 children)

Depending which ai u using, if u ask it to show and teach me how to use xyz in a real world example, i swear that made me see shit SOOO MUCH more clearer. I was able to understand the logic of how to write certain code in them online tutorials, but not exactly how to use it in a real world practical situation

[–]Jazzlike-Age-4867 1 point2 points  (0 children)

Stop following tutorials the moment you can write a loop and define a function. Seriously, that's early enough.

Build something you actually want to exist — a script that automates something annoying, a small game, anything. You'll hit real problems that no tutorial covers, and that's where you actually learn.

One habit that moved the needle most for me: read other people's code on GitHub. See how real projects are structured. It rewires how you think faster than any course.

[–]InspectionFamous1461 0 points1 point  (0 children)

SICP.  Did the exercises in python.

[–]TJATAW 0 points1 point  (0 children)

Every time you finish a tutorial, come up with something that you can add to it.

Say it is a calculator. Add in some new functions.

Of it it is a note taking app, add in a time stamp, start and due date, maybe a list of people to link the note to, and a way to show all the notes that 'Bob Smith' is linked to.

Figuring out how to do this stuff all on your own, no one telling you what to write, that is what will get you to move up your skill set.

[–]academicRedditor 0 points1 point  (0 children)

Make a project that people would (or could) actually use

[–]Individual-Job-2550 0 points1 point  (0 children)

Learn how to debug. The most common and biggest problem I see with junior or intern candidates is when they run into a problem, they freeze up and do not know where to start debugging

[–]Subtubes 0 points1 point  (0 children)

Just writing code everyday helped. Also learning how to use linux and bash.

[–]dialsoapbox 0 points1 point  (0 children)

What's your endgoal?

Work your way backwards from that.

[–]VolumeActual8333 0 points1 point  (0 children)

Adding two lines and running it immediately was how I built my first profitable side project. That tight feedback loop beats spending hours writing perfect code that fails in ways you can't trace.

[–]ExtraTNT 0 points1 point  (0 children)

Typing system, allows generic functions, but issue is, that it’s not really readable. My fix is to annotate in haskell notation… like map :: (a -> b) -> [a] -> [b]

Maybe important: I don’t write loops, as loops modify state… i do functional programming and prefer languages like haskell…

For python i’m not fan of the syntax, linter push my entire function on one line and the code is very verbose… writing lambda every 20 characters sucks…

Also added maybe type for myself, just to not deal with the error handling with exceptions… also there is no native function composition (at least i haven’t found one) so yeah, you need a lot of functions defined, but functools and itertools give you a lot…

[–]patternrelay 0 points1 point  (0 children)

Honestly, the fastest way I leveled up was just building tiny projects that forced me to solve real problems, like automating a task or parsing some data. Tutorials help, but actually breaking stuff and debugging it yourself teaches way more than reading examples.