How I Set Up Python, Git, and VSCode as a Beginner (Without Breaking Things)

🧠 Introduction:

When I first opened VSCode, I stared at the screen like it was an alien spaceship.
I had Python installed (I think). Git? Still a mystery. GitHub kept asking me for SSH keys like it was a secret club I didn’t have the password for.

Sound familiar?

If you’re just starting your programming journey, trust me — I’ve been there. Setting up your coding environment shouldn’t feel like hacking NASA. But most tutorials assume you already know what “PATH” is, or why .gitignore matters.

In this post, I’ll walk you through how I set up Python, Git, and VSCode step-by-step — as a total beginner — and more importantly, the dumb mistakes I made that you can now avoid.

💡 By the end, you’ll have a clean, working dev environment and actually understand what you just did. No fluff. Just real talk, real fixes, and a few “oh wow” moments. Let’s go.

---

🧩 1. Why Setup Matters (Don’t Skip It!)

🚨 “I coded for two days straight… and lost everything.”

That’s not a dramatic clickbait line — that actually happened to me.

As a total beginner, I dove headfirst into Python tutorials on YouTube. Everything was going well… until it wasn’t.

I hadn’t set up Git, had no clue what version control meant, and I was writing all my code in a random folder on my Desktop named stuff.

Two days of hard work disappeared in seconds — overwritten, unsaved, and unrecoverable.

💡 The Hard Truth No One Tells Beginners:

Most people think setup is “boring” — just install Python, open VSCode, and start coding, right?

Wrong.
Without a proper setup:

• You won’t know what broke when things stop working.
• You’ll waste hours googling weird errors you could’ve avoided.
• You’ll be scared to experiment, fearing you’ll mess up your system.

✅ Here’s What a Good Setup Actually Gives You:

• Confidence: You can break things, fix them, and keep learning.
• Speed: One-click file runs, fast debugging, better focus.
• Control: Know where your code lives, what’s changing, and why.
• Safety: If anything goes wrong, Git’s got your back.

🔍 What I Wish I Knew Earlier:

A clean environment isn’t just about looking professional — it’s about thinking clearly.

When your tools are set up right, you think better, code smarter, and stop feeling like you’re always one typo away from disaster.

✅ By the end of this article, I’ll help you avoid every painful mistake I made — and set up a Python + Git + VSCode workflow that feels buttery smooth.

👉 Let’s start with Python — and the PATH trap that almost made me quit coding.

• Real-world issues I faced because of poor setup
• How a proper setup saves hours in the long run

---

🧪 2. Installing Python: What Went Wrong the First Time

❌ “Python is installed, but terminal says it isn’t.”

That one sentence sums up my 3-hour war with PATH variables.

I downloaded Python from the official site, clicked “Install,” and expected magic. Instead, I got:

python: command not found

What?! Didn’t I just install it?

Turns out, I had installed Python, but not properly added it to PATH — which is like installing a kitchen but forgetting to connect the gas line.

🧱 The Mistake I Made (And Most Beginners Make Too):

I didn’t check the little box during install that said:
✅ Add Python to PATH

That one tiny checkbox? It’s everything.

Without it, your system doesn’t “know” where Python is, even if it’s sitting on your disk. So commands like python or pip won’t work in terminal — and your frustration will hit the roof.

🤯 Bonus Confusion: Two Pythons?

To make it worse, I had two Python versions:

• Python 2.7 (pre-installed)
• Python 3.12 (what I installed)

Guess what? The terminal kept using Python 2.7. And none of my modern packages worked.
I was trying to install pip and run scripts — everything broke.

🧠 What Finally Worked for Me:

Here’s my personal working stack (that I now trust with my life):

Component	Version	Why It Worked
Python	3.10.x	Stable, widely supported by packages and extensions
Installer	Official from python.org	Clean setup, no pre-bundled junk
Install Tip	✅ Check “Add to PATH” during install	Avoids 90% of command issues
Test It	Run python --version and pip list in terminal	Confirms proper install

⚙️ Pro Tip (That No One Tells You Early):

💡 Run this in your terminal to see all Python paths messing things up:

where python  # Windows  
which python  # macOS/Linux


And clean up any weird Python versions you’re not using.

🎯 TL;DR:

• Always use the official Python installer.
• Always check “Add to PATH”.
• Avoid system Python — stick to Python 3.10 or newer.
• Don’t install 3 versions “just in case.” You’ll go mad debugging.

---

🌐 3. Installing Git & Creating My First GitHub Repo

🤯 “Wait… what’s the difference between SSH and HTTPS?”

That question haunted me during my first GitHub push.

I thought Git was just some command that saved my code. Suddenly, I was asked to choose between SSH and HTTPS, generate keys, copy URLs, and paste tokens.
And I hadn’t even written 5 lines of code yet!

🚫 The Mistake Most Beginners Make:

I followed a tutorial, typed this:

git remote add origin https://github.com/myname/myrepo.git

…and then:

fatal: repository not found

Or worse:

permission denied (publickey)

That’s when I learned:
Git only works when your computer knows who you are — and has permission to talk to GitHub.

🔐 SSH vs HTTPS (Explained Like I’m 12):

• HTTPS = Easy to start, but you’ll enter your password/token often.
• SSH = Harder to set up at first, but then it just works like magic.

I tried SSH… but messed up my key setup. That’s when I installed GitHub Desktop — and suddenly, it all made sense.

⚡️ The Aha! Moment: GitHub Desktop Saved My Brain

GitHub Desktop let me:

• See all my commits visually (no scary terminal needed)
• Sync changes to GitHub with one click
• Understand the real power of version control

After that, I came back to the terminal with confidence — and finally made Git work on my terms.

🔁 The One Step I Kept Forgetting (And You Might Too)

Every time I made a folder for code, I typed:

git status

And got:

fatal: not a git repository

Why?
Because I forgot the most important command:

git init

Without git init, your folder isn’t being tracked by Git — it’s just another bunch of files.

✅ What Finally Worked for Me:

git init
git add .
git commit -m "First commit"
git branch -M main
git remote add origin git@github.com:yourname/yourrepo.git  # or use HTTPS
git push -u origin main

And boom — my first real GitHub repo was live 🚀

💡 TL;DR:

• Use HTTPS if you want quick setup.
• Use SSH if you’re serious long-term (GitHub even has step-by-step key guides).
• Use GitHub Desktop if the terminal freaks you out — it’s a great learning bridge.
• And don’t forget git init — or nothing gets tracked!

---

💻 4. VSCode Setup That Made Me Love Coding

✨ “This editor feels like mine now.”

That’s the moment I knew I’d stick with coding.

It didn’t come from finishing a tutorial…
Not from solving a bug…
It came when I opened my code and thought, “This feels clean, smooth, and powerful.”

That moment came after I finally got VSCode set up right.

🔌 The Extensions That Changed Everything

When I first opened VSCode, it felt plain and confusing. But then I added just a few powerful extensions — and suddenly, it became my coding command center.

Here are the ones that stuck:

🐍 Python (Microsoft)

• Auto-suggestions, code linting, run/debug with a click.
• Bonus: It detects virtual environments automatically.

🌲 GitLens

• Shows who changed what in every line.
• Helped me finally “get” version control.

💬 Code Spell Checker

• Saved me from dumb typos like pritn() or defualt.

🧠 IntelliCode

• AI-powered suggestions trained on real projects.

🎨 Theme + Font = Comfort & Focus

Theme I use: One Dark Pro — dark, clean, easy on the eyes
Font: Fira Code — it makes symbols like => and != look beautiful
Font ligatures: ON
Font size: 14px
Line height: 1.6 (feels more spacious)

🧾 Terminal Setup That Felt Right

I switched VSCode’s default terminal to bash/zsh with:

"terminal.integrated.defaultProfile.linux": "bash"

Then I added some terminal aliases like:

alias gs="git status"
alias gc="git commit -m"
alias gp="git push"

Now, I feel fast and in control every time I open the terminal pane.

😖 Auto-formatting Frustration (And Fix!)

At one point, VSCode kept fighting me.
Every time I saved a file, it messed up my formatting.

The culprit? Conflicting formatters.

Here’s how I fixed it:

1. Install black (the opinionated Python formatter):

pip install black

2. Update VSCode settings:

"editor.formatOnSave": true,
"": {
  "editor.defaultFormatter": "ms-python.python"
}

3. Add this .vscode/settings.json in your project:

"editor.formatOnSave": true,
"": {
  "editor.defaultFormatter": "ms-python.python"
}

Now every time I save — my code looks ✨ clean.

💡 Pro Tip:

If you’re ever unsure what’s breaking your autoformatting, disable all formatters and re-enable them one by one. Or use Ctrl + Shift + P → Format Document With… to choose manually.

❤️ Why It All Mattered:

Coding became fun not when I “got better” at Python, but when I enjoyed sitting down to code.
The look, feel, and power of my tools made a huge difference.

---

🛠️ 5. My Final Beginner Setup (2025)

“If I had this setup from Day 1, I would’ve saved 3 weeks of frustration.”

Let me show you the setup that finally worked for me — not the one from tutorials that skip over the hard parts, but the one I actually use, tested with trial, error, and lots of YouTube rabbit holes.

This setup is clean, minimal, and rock-solid for any beginner getting into Python and Git — especially in 2025.

🐍 Python 3.12.3 — Because Version Matters

Most tutorials still say “install Python” like it’s one-size-fits-all. Nope.

The first time I installed Python, I:

• Got the wrong version (3.6… which didn’t support some libraries)
• Skipped the “Add to PATH” option
• Broke pip trying to “fix it manually”

After fixing it, I settled on:

Python 3.12.3 (official, stable, long-term supported)

It’s fast, compatible with modern libraries like pydantic, fastapi, poetry, and smooth with VSCode.

✅ Pro Tip: Use pyenv if you want to switch versions easily later.

🐙 GitHub CLI + SSH Key Setup — No More HTTPS Headaches

At first, I was stuck with copy-pasting HTTPS links and typing my GitHub password every time. Annoying!

Then I discovered the GitHub CLI (gh) and SSH keys.

Here’s my setup:

sudo apt install gh
gh auth login
# Follow the prompt and generate SSH keys

Now I can push to GitHub without passwords like a pro:

bashCopyEditgit push origin main

SSH + GitHub CLI = fewer errors, better security, smoother workflow.

💻 VSCode Extensions — My “Starter Stack”

Here’s the exact combo that turned VSCode into my personal IDE heaven:

✅ Python (by Microsoft)

• Linting, running code, debugging — all in one.

✅ GitLens

• Visual history of changes with author insights.

✅ Jupyter

• Great for running Python snippets inline or testing logic visually.

✅ Prettier (code formatter)

• Keeps all files clean (not just Python — also JSON, Markdown, HTML).

Bonus settings I use:

"editor.formatOnSave": true,
"files.autoSave": "onWindowChange"

---

🧩 Bonus Setup Add-ons

• Fira Code Font (with ligatures)
• One Dark Pro Theme
• Terminal Profile: Bash with aliases

🎯 Why This Setup Works for Me

It’s not just about what you install — it’s how it feels when you sit down to build.
With this setup, I no longer worry about “why it’s not working.”
Now, I focus on learning Python, building projects, and getting better.

✅ TL;DR – My Beginner Dev Stack (2025)

Tool	My Setup
Python	3.12.3 (official installer)
Git	GitHub CLI + SSH
Editor	VSCode
Key Extensions	Python, GitLens, Jupyter, Prettier
Terminal	Bash (with gs, gc, gp aliases)
Theme/Font	One Dark Pro + Fira Code

---

😬 6. Things I Wish I Knew Earlier (So You Don’t Have To)

You know that moment when you’re weeks into coding and suddenly realize you’ve been doing something completely wrong?

Yeah… I’ve had a lot of those.

Let me save you from three of my biggest beginner facepalms — lessons I wish someone had shouted in my ear on Day 1.

🎪 1. Always, Always Use a Virtual Environment

Mistake I made:
Installed all Python packages globally. Broke everything when I switched projects.

What I should’ve done:
Create a virtual environment for each project. Think of it like a bubble where your project lives with all its own stuff — neat, clean, and safe.

python3 -m venv env
source env/bin/activate

Now each project has its own private world. No more “why is this package version breaking my other app?”

📦 2. Use .gitignore from Day 1 — Not Day 27

What happened:
I pushed my entire folder to GitHub… including secret files, logs, and junk. 🤦‍♂️

How to fix it:
Create a .gitignore file before your first commit.

Just add:

__pycache__/
env/
*.log
*.pyc

Or better, use a template like:

👉 https://www.toptal.com/developers/gitignore

It saves your repo from looking like a junkyard.

🔥 3. Never Push __pycache__/ (Please Don’t)

This one still haunts me.

I didn’t know what __pycache__ was. It sounded like something Python needed, so I left it there and pushed it to GitHub.

Result:
My repo was bloated with unnecessary files, and other developers raised their eyebrows.

What I do now:
.gitignore takes care of it. You should never push auto-generated folders. Keep your repo clean.

💡 Pro Tip: Set Up Once, Use Forever

If you’re tired of remembering these steps, create a starter template or cookiecutter project with:

• Virtual environment setup
• .gitignore preconfigured
• README file with instructions

Now you start every project like a pro — not like someone learning from their past mistakes (like me 😅).

👇 TL;DR for My Future Self (And You)

• ✅ Always use a virtual environment
• ✅ Add a .gitignore file before pushing
• ❌ Never push __pycache__/, logs, or secret files

---

📚 7. Resources That Helped (and Actually Made Sense)

When you’re starting out, Googling every error feels like a full-time job. But amidst the chaos, I found a few golden resources that truly made things click.

These weren’t just random tutorials — they were like the mentors I didn’t know I needed.

🐍 Python Official Docs (Wait, They’re Not Boring)

🔗 https://docs.python.org/3/

At first, I avoided the docs because I thought they were too complex. But once I got past the initial fear, I realized:
👉 They’re clear, well-structured, and actually better than most tutorials.

Especially when I wanted to understand how venv or pip really works — this was the place.

🎥 freeCodeCamp YouTube Channel

🔗 https://www.youtube.com/c/Freecodecamp

One word: lifesaver.

Their “Python for Beginners” series gave me the confidence to write my first real project. Their videos are:

• Beginner-friendly
• Ad-free
• Taught by devs who get it

The visuals and real-world examples helped me connect the dots much faster than text tutorials.

🔐 GitHub Docs: SSH Key Setup That Finally Worked

🔗 https://docs.github.com/en/authentication/connecting-to-github-with-ssh

The SSH setup was a nightmare at first — until I stopped bouncing between Reddit threads and just followed the official GitHub guide.

Pro tip: Skip HTTPS and go straight to SSH. It’s more secure and way more convenient after the initial setup.

✨ Bonus: Stack Overflow (But Filter Carefully)

Yes, it’s chaotic. But when used intentionally, Stack Overflow taught me not just the solution — but how to ask better questions.

💬 Real Talk

You don’t need 100 resources — you need 3–5 really good ones you trust. These helped me:

• Set up Python and Git the right way
• Understand what’s actually happening under the hood
• Avoid spending hours stuck on silly issues

---

🎯 Final Thoughts: From Confusion to Clarity — My Aha Moments

When I started my programming journey, I believed the lie that real learning only happens through struggle. I thought being “stuck” was normal. That confusion was a rite of passage. And while some struggle is inevitable — unnecessary struggle is just bad guidance.

This post isn’t just a list of resources. It’s a map of what finally pulled me out of the chaos.

💡 Aha Moment #1: Official Docs Aren’t Just for Experts

I always assumed docs were written for developers in some Silicon Valley lab. But when I slowed down, I realized:
The docs are like instruction manuals written by the creators themselves. They explain why things work, not just how.

Once I learned to read them without fear, I stopped depending on broken Stack Overflow threads and outdated Medium blogs.

💡 Aha Moment #2: YouTube Is the New Coding School

Platforms like freeCodeCamp made me feel like I had a front-row seat in a real class — minus the pressure.
Watching a real person explain concepts, make mistakes, and fix them in real-time taught me more than any blog post could.

The aha?
Visual learning accelerates confidence.

💡 Aha Moment #3: GitHub Docs Saved Me From Rage Quits

SSH keys, .gitignore, merge conflicts — it all felt impossible at first. But the GitHub docs didn’t just explain what to do — they told me why it works that way.

The moment I successfully pushed to my first private repo using SSH, I literally said out loud:
“Wait… that’s it?!”

💡 Aha Moment #4: Fewer Resources = Faster Learning

I wasted too much time juggling 15 tabs, 7 YouTubers, and 20 blog posts.
Once I focused on 3-5 high-quality sources, my learning sped up. My errors reduced. My confidence grew.

Quality beats quantity.
Clarity beats noise.

🚀 Where This Leaves You

If you’re just starting your coding journey, remember this:

• You don’t need to figure it all out alone.
• You don’t need to feel lost in a sea of conflicting advice.
• And you definitely don’t need to “struggle through it” just to prove you’re serious.

You just need a few reliable guides, a clear setup, and the permission to go slow.

This was my map. I hope it becomes yours too.

---