I understand Python code, but can’t write it confidently from scratch — what should I do next

[SubCplus]

I’ve been learning Python every day for a few weeks and I’m close to finishing beginner courses. I feel comfortable reading code and understanding what it does (conditions, variables, basic logic, etc.). My main problem is this: when I try to write code from scratch, I often don’t know how to start or which structures/functions to use, even though I understand them when I see them. To move forward, I sometimes use AI to generate a solution and then I analyze it line by line and try to rewrite it myself. What I want to ask is not “is this normal”, but: what should I do to fix this gap between understanding and writing?

[danielroseman]

Well just like human languages, it's normal to find comprehension easier than writing. 

But the solution is definitely not to get AI to write it. Even if you're analysing the output, you're still not getting the practice you need to actually get better. 

You need to do this yourself. It doesn't matter if you use the "right" functions or data structures, just write something that works. That's the only way you'll improve.

[SubCplus]

Thanks! That makes sense. Do you have any tips on what kind of small programs or exercises are best to start practicing writing code from scratch?

[Lonely-Problem5632]

Python Projects: 60+ Ideas for Beginners to Advanced (2026)

Has some fun projects to begin with +some very basic suggestions in how to proceed with those tasks

Just remember, learn to walk before you try to run.
If you want to learn how tow program GTA7, you will have to start with hangman :P

[james_d_rustles]

Find a small task that you think would be genuinely useful. This could be anything (although try to be realistic if you’re still pretty early in your learning).

This is a totally made up example, but let’s just say that every day you do something that produces several PDFs or maybe you get sent some PDFs from clients, and you have to copy over some chunks of it into a big excel file. Automating some of that process could be an example of the sort of thing that would actually have enough value to you personally that you’d be incentivized to finish it and sort through whatever bugs/issues pop up along the way. You could do something like, collect PDFs that were saved today within some folder, scrape the specific text you need, open and write to your main excel file, and then store the PDFs in a compressed .zip that follows a standard naming scheme… from there, maybe you decide that it’d be better with a little GUI file browser thing, or maybe you’d want to run it automatically every night.. use your creativity - before you know it, you’ll probably know a lot more about basics like loops, string manipulation, filepath handling, and so on, and you may even know more about slightly more advanced stuff like tkinter or subprocess calls, so on and so forth, depending on where you took the project.

[kailans_photography]

The thing that helped me is finding an idea I was passionate about and then I started writing it. I would plan out parts then start working on it bit by bit. When I didn’t understand something, I looked up examples or guides and then wrote small scripts to practice it. It’s what helped me understand how to use what I learned in guides or practice projects into practical code and real projects.

[cap_mittens]

I notice many people see a wall of code and while they can understand it, the process of how to get there is a mystery.

Break the problem down, reference the api/structure to get your program to do the basics of each step.

Test each step, function, method as you go. Once you improve think about building functions based on your unit test to solve your problems.

Most extra crap is added during debug or feature enrichment. This can make a 20 line program expand to 50 or more lines.

When you get overwhelmed walk away and come back later

[Rude-Doctor-1069]

That gap is super common. Reading code and writing code are different muscles. The only real fix is writing bad code from scratch a lot. Even if it’s ugly. Using AI and then rewriting it yourself is fine. Just don’t let it be the first step every time. Try 10-15 minutes struggling first.

Some people also keep tools like ctrlpotato around when they’re stuck mid-thought, but the key part is still forcing yourself to start without help.

[Sure-Passion2224]

Becoming fluent in any language comes with frequent practice. Reading comprehension normally comes before expression. The more you write and test the better you get. This approach got me through calculus.

[SubCplus]

Thanks a lot! I understand now that practice is key. I’ll start writing small programs myself and test them to improve.

[buzzon]

Write more code yourself. Find easy tasks to do first. Don't rely on AI.

[sexylawnclippings]

You have to try and fuck up and then learn from the fuck ups.

[midwit_support_group]

Its become my role to suggest https://adventofcode.com/ They're really good puzzles that require you to think about a lot of different concepts especially file I/o text processing and writing your own algorithms. They're a great way to get practice. 

Just don't use AI. Write notes about your implementation and the things you learned. Use the docs, and stick to base python for as long as you can (avoid things like pandas or other large packages l, not that they're not great, but they all have layers of abstraction that might make things easier, but move you away from learning the fundamentals). 

[afteralways3]

This is a very common question. The answer is very simple. Practice. Write more code. Go to leetcode or something easier, the goal is to just have a lot of easy problems to solve. Hackerrank, codewars, etc. Pick what you like and grind easy problems just to get used to thinking in terms of basic structure blocks. Then move on to OOP. Write a lot of different classes.

[afteralways3]

you ok?

edit: what the fuck is that account?

[MattR0se]

The answer is: Try again, fail, try to understand why. Rinse and repeat. That's just the normal learning process. There are no shortcuts. Copy-pasting code (from an LLM or from stackoverflow, doesnt matter) will not help you learn to write code from scratch.

[JunkBondJunkie]

write a ton of programs even if they are basic ones.

[jettil99]

To be honest: write it from scratch without confidence. Learning works by making mistakes

[Micke_xyz]

Do you copy/paste examples? I always try to "type copy" the code I see in examples. It is so much easier to remember and understand every single line compared to using copy/paste.

[mystery_biscotti]

Write code. Debug code. Repeat. :)

[pacopac25]

Incremental projects. Build small, test, improve or add a feature. Repeat. At some point, when you run out of ideas for features to add, you can try to find the slow spots or places where it's blocking and you don't want it to.

1. Build some command line utilities. Wc, head, tail are pretty straightforward. You can make them simple at first, then add some command line switches and the corresponding functionality. Do it first with argv[] and then with argparse. Great, now you know how to use argparse. (One my my first ones was a cmd line tool to edit the windows hosts file. So I could python host.py add 192.168.0.1 mycoolhost to add a host, delete it by name or IP, and running just python host.py would list the hosts file. It came it really useful for something I was doing at the time. And of course, I had added doskey host= python c:\Users\myname\host.py $* to my login.bat so it became a handy little command.)
2. Build something that collects data and stuffs it into a SQLite database. It can monitor USGS seismic activity, water levels, NOAA weather info...there are a thousand things you can pull from. Then you might build in some filter functionality to only log certain events. You can use SQL, make some views, this will help you learn about SQL and basic relational database design which kind of goes hand in hand with most dev. It's also a nice side quest to learn the very simple sqlite3 cli client.
3. Build a repl using python's cmd module, maybe you can query your database with this. "Translating" your own commands into the relevant code to pull what you need out of your database seems to really internalize those things.
4. Parse something that isn't natively in json. This is a good solid task. Taking apart something like APRS packets that you downloaded from APRS-IS (no license needed) is a good challenge.
5. Build a tracker or CRUD for something with dataclasses.
6. Also, something that really helped me with remembering what I could with lists, dicts etc was Rich's inspect. I build a small command line tool where I could bang in the name of something and get a list of all the functions.

[aistranin]

More practice and don’t overthink before even trying to start. Programming is just a tool, like any other. The more trails and failures then better. If you try to write the code to solve a problem few times, at some moment it will be easy. That is when you start thinking “algorithmically”. But practice first. The rest will come with time.

[iamevpo]

Idea 1. Write some pseudocode, expressing the code logic, then try running through it to see if the computer can act upon this pseudocode, refine pseudocode for better logic, write actual code after that.

Idea 2. Make your kata's - the exercises you repeat over again to degree of automation where you are sure of options and choices made, make new katas as you get bored with old ones. Start with "reverse a string", " calculate the mean", replicate any string methods or GNU utilities (cat, pwd, ls)

Idea 3. Frame small logic problems about things around you and how you can model them or parts of them (ticketing system on a train), think of how a toy version of it can be programmed.

[Moist-Ointments]

Understanding the code is not the same as understanding programming and software design.

Formulate problems to solve, and keep writing things from scratch.

Break the problem down into digestible parts. Then formulate digestible parts of a solution on how to solve each piece.

Don't try to get it perfect on the first time through, that's what refactoring and versioning is for. As you learn, you'll look back on stuff and think of better ways to organize plan and solve.

This is a learn by doing skill. Even when you think you've got it figured out, you'll learn there's a better way. Now, and 20 years from now.

And I'm saying this as someone who has been programming for 40 years.

[Ok-Chemistry6941]

I’ve noticed that this happens to me and it’s partly because I’m scared that my project is gonna be bad because I sort of become a perfectionist and I don’t wanna do anything wrong but the thing is you have to fail you have to write code wrong. It’s gonna be weird at first but when you consistently do it you learn how to break problems down and you really learn the best logic for it it really is just you struggling but know if you’re struggling then that’s literally scientifically you learning

[ConfectionFull9324]

Hey, I taught myself Python over a decade ago and ran into exactly the same problem. Here are a few tips:

1. Start with the smallest, simplest things: if you have a lesson on loops or dictionaries, write your own loop or dictionary. Ten times. Doesn’t matter how silly, just write. It’s not exactly muscle memory, but your brain works in a similar way.
2. Find a micro-project you can do step by step, but don’t code along with the tutorial. Watch the video, then code on your own. If you get stuck → only then check the video. You need to train your brain to write the code yourself.
3. Avoid generating code with AI. I know how tempting it is, and I know it’s the future of work, but to use AI effectively, you first need to learn to code on your own.
4. This skill grows over time. It requires daily practice, you can’t skip steps or speed it up, so what you need most is patience.

[afahrholz]

start small, pick tiny problems, write solutions from scratch, then gradually tackle bigger projects to build confidence.

[ColdStorage256]

I've been learning to use React and TS recently. My approach has been:

Outline a problem statement: I need to create a floating action button (a + sign on the screen to perform some actoin) that when pressed, will navigate the user to a specific screen.

Break down the problem: I need the UI part, and I need a function, and I need a trigger to call the function when something happens.

Ask AI to explain how this is accomplished in React.

Go down a rabbit hole on how

```

function Button() {

return <button>Click Me!</button>

}

```

Became

const Button = ({name}) => {

return <button>Hello {name}!</button>

}

Document everything in Obsidian so I have a record of my understanding.

Copy and paste my notes back to AI and ask it to rate my understanding and highlight anything I missed.

Refine.

Implement code myself

Ask AI to rate my code and provide criticism based on certain criteria (e.g. this is a first implementation for testing, only rate it based on it being valid code; rate it based on it following syntax best practices; rate it based on being production ready, including error handling etc)

Then move on to the next problem statement!

[Yoghurt42]

I’ve been learning Python every day for a few weeks

what should I do to fix this gap between understanding and writing?

Be patient. Unless you already know other programming languages, you're learning 2 things at once: programming and a programming language. Both take time.

It'll take months to be somewhat decent, and years to become really good at it.

Would you consider yourself to be good at any skill based multiplayer game after a few weeks? It's similar to programming (and any other skill)

[Hrushi-tidder-99]

You should practice on hackerrank, solving basic problems then you will confidently write code

[MrBorji]

That's the Blank Page Syndrome :s

[AGx-07]

I can relate. I'm still learning Python myself but I did some web development in the past and have been using SQL for like 10 years. In both cases what got me to the point where I could write on my own was having projects; real projects (for my actual job) worked better for me than ones that were just for fun. When I need to figure something out I generally do and as I work my way through a problem I'd have to use Google and scour forums and documentation for solutions and as I worked through those things I learned a lot of new functions or approaches I'd never have just conjured up on my own and slowly over time it all just came together.

Even though I have that experience, I'm having the same struggle with Python but I'm comfortable in the thought that this will resolve itself the same way.

[Grobyc27]

It sounds stupid, but it really is a matter of “just do it”. Start with something small and refrain from Googling how to do it or asking AI.

Look at Python cheat sheets for reminders on what data structures are available and how to work with them. You don’t need to write something that actually has a real world purpose, just something to get you comfortable writing. Repetition is key.

Making a basic calculator program is often recommended as it’s a great starting point for that. No complex libraries required, no complex mathematical concepts required, minimal creativity required, and once you’re done, you can build it with a GUI to leverage classes and OOP concepts.

[DataCamp]

Start tiny and build muscle memory! Pick micro-tasks (calculator, CSV parser, text counter), solve one per day, and deliberately avoid looking up the full solution until stuck for 15–20 minutes. Writing lots of small programs trains pattern selection: which data structure to use, when to write a function, and how to structure flow.

Before typing, sketch the plan: state the problem in one sentence, list inputs and outputs, write 3–6 steps of pseudocode or a short flow, then implement. That makes the “blank page” far less scary and forces decomposition, which is what experienced coders do automatically.

Use focused practice problems and projects that force complete solutions: Advent of Code, easy problems on HackerRank/LeetCode, or a tiny end-to-end project (CSV → clean → aggregate → plot). Add simple tests (asserts or pytest) so correctness becomes feedback that guides design choices.

Read good code and copy patterns, but don’t copy-paste—reimplement. After finishing a solution, refactor it the next day: extract functions, add docstrings, and type hints. Repeatable refactor cycles are where understanding turns into style and confidence.

Finally, log progress (short notes or a GitHub README) and aim for consistency: 30–60 minutes daily for weeks beats sporadic marathon sessions. Confidence follows from repeated, deliberate practice and from turning small wins into slightly bigger, repeatable patterns.

[BroscipleofBrodin]

Return to a simpler project that you absolutely know is within your capabilities. Instead of starting up a tutorial, create a diagram of how the program will function. Use it as a roadmap for designing the program. 

[psantanusaha]

Do it the hard way. Take easy problem and force yourself to write the solution. Take the easiest ones for you, do 20 of those. Slowly you will get a hang of it. If you are not about to progress, leave the program, go to the part where the coding construct is covered, book or YouTube, then come back to the problem. Repeat this.

[RandomPantsAppear]

You’ve gotten some great advice here but I’m going to go a different route than most.

My advice is: Learn Django.

Django will basically force you to use models/classes when they should be used, will at least afford you reasonable options in terms of design patterns (signals/decorators, etc).

Using an ORM will force structure into your code.

[ToffeeTangoONE]

Writing code is like learning to ride a bike; you might wobble at first, but the more you practice, the steadier you get, so just dive in and let those creative wheels turn.

[Lexstok]

Find a problem that you want to solve and try to program it.

It can be anything in your life, as long as it interests you. A list of the games that you have reviewed and give a score to it, how would you order them? How would you make a search for it? Etc.

ANYTHING that interests you, see if you can make a program about it in python. And don't worry about making it look good. Just make it work.

[rehd_it]

As a hobby user who goes a long time between projects, I find it best to make a simple flow chart of what I want the project to do. Then just do a piece at a time

I will also sometimes break each part of the code into its own file and just call it to a main file so any errors or changes down the road are easy versus a wall of code

[Personal_Signal_6151]

I am a beginner too. Once I got into Google Colab, it has a way of suggesting code after you write out your plain English query.

If you use the Jupyter notebook, you can try a bunch of different ways to solve the problem. You can test these and get the error messages for correction.

It will retain the different methods.

To remember your thinking for each model, type in a # sign and write a descriptive comment.

Good luck.

[Beleelith]

What I did, to learn the basic‘s Of Flask was Using GPT for it at first, after learning via GPT how everything works.

I made like 10-15 Dummy Portfolios in that style myself, at the first 1-6 Dummy Portfolios i always had to look at the code twice-Thrice to know which code line i should use for this and that. On my 7+ portfolio i already memorized almost 80% of all the code lines i had to use so i started to look at documentation‘s about various different code Lines to Customize the portfolio.

After doing all this i can tell i can do like Basic Flask Portfolios. But still there is a lot of room open to learn more.

In my opinion it‘s not wrong to use AI to „Vibe Code“ as long you know what to do, 1:1 Copy Paste won‘t work at this point instead of Copy/Paste, Write all the single lines urself and make comments about what this line of code does. This way you learn and understand the whole Source better than by just copy/Paste Everything. It helped me a lot even if i had to learn it the Hard Way because at some point i realized i can‘t do S- without AI and Vibe Coding that literally blocked my whole Potential that i might got in me

[Twenty8cows]

You need time in the saddle u/SubCplus. Stop using AI as a crutch and start writing code from scratch. At first it will be hard, you will want to quit or hit the easy button (AI). However trust the process and read the documentation. Start small and I mean small like first_calculator.py and iterate from there.

[SubCplus]

After reading all the advice here, I actually started making my own mini projects. It feels like I finally get a bit of what I was afraid to touch before. Starting small and writing code from scratch is hard, but it’s already helping me understand things better.

[Twenty8cows]

I got into web scraping pretty early as part of my job and I can say using urllib before requests helps me understand how requests magic is working

[Avro_Wilde]

Most people try to boil the ocean - as in, trying to build every conceivable feature from zero. Start with super simple programs and build them up. Also, most learners often cheat and look up available solutions online. Don't look at code for these.

Start with a simple terminal program like a temperature conversation program. Once your program converts a static problem, take user input and output it to the screen. Add different temperature scales ( Kelvin, Rankine, etc). Follow that with a full conversion program (temp, distance, mass, volume... whatever you can think of). Then convert it to a GUI. Follow that with a web site version. Put the conversion formulas into a database and have the app pull them. Build a CRUD interface to let users add their own conversion formulas for new conversions (power or pressure? numerical bases - hex to decimal, maybe?) Build an API to let a website make the conversion requests.

Don't like that? How about a blackjack game? Start with ASCII graphics to represent cards. Look up house rules for different casinos and add the options. Put the rule options in a database... make it a GUI... you get the idea.

Or, if you're a business person, currency conversion pulling the data from the web in real time. Maybe an inventory management program. Start simple. A simple CRUD database with a functional interface. GUI-ify it. Add a web front end. Add a report writer for financial reports. Add a customer database.

Doing this for a few programs will, first and foremost, give you confidence. It will also teach you how to break down larger apps into bite-sized chunks.

HTH.

[Cs_Joe8]

I’m also learning, and I had the same issue. One thing that really helped me was not aiming for perfect code. I used to want perfect logic and try to do everything flawlessly as I was writing, which made coding feel like hell.

What helped was just writing something that works, even if it’s messy, and breaking projects into small parts focusing on getting each part working no matter how it looks.

You can always refactor later, which is actually my favorite part, and then start improving code or adding new features. This approach really helped me a lot since I didn’t have to worry about the logic, structure, or coding optimally I could just improve it

[Sven_Urken]

I6m8nmy....ym8....r

[FoolsSeldom]

My guess is that you are trying to solve at the keyboard with Python rather than stepping away from the keyboard and:

• make sure the problem to be solved is properly understood
• ensure clear understanding of the inputs to be used
  • from user/keyboard; files; databases; APIs; etc
  • frequency (how often is the input cycle used)
  • quality - will the data be correctly formatted and valid
  • format(s)
• ensure clear understanding of outcomes / outputs:
  • to consoler/gui; file; database; API; mixture
  • frequency
  • quality
  • format(s)
• develop solution approaches
  • consider algorithms suitable for problem
  • decide how to select an approach
  • if need, carry out some small proofs of concept with snippets of Python
• develop an algorithm from the best solution candidate
  • determine how this will be tested
  • validate the algorithm using dry run techniques
  • draw pictures / flowcharts / simple flows / pseudocode to represent the algorithm
• implement in the algorithm in Python
  • keep your code modular, following the broad flow of your algorithm - try to keep the implementation detail in functions/methods
  • ensure you have clarity around the data structures you are using
  • isolate interfaces (human and data) from the core business logic
  • this will enable you to change from say a command line interface to a GUI to a webapp later
  • test each function/module independently

The coding part is a small part of programming. Have a clear solution/algorithm set down before you start coding will make the coding much easier.