Building a CLI in Python with Click

5 small habits that make you a better developer instantly 1️⃣ Use Git properly (not just commit & push) Learn: - git stash → save work without committing - git rebase → keep history clean 2️⃣ Stop rewriting code — reuse it In Python/JS: - Write small reusable functions - Don’t repeat logic Cleaner code = fewer bugs 3️⃣ Use your terminal more Simple commands save time: - history - clear - !! (repeat last command) 4️⃣ Read error messages fully - Most answers are already there. - We just skip reading. 5️⃣ Use AI to understand, not just generate Ask: - “Why does this work?” - “What’s the better approach?” These aren’t “advanced” skills. But they separate: 👉 people who code from 👉 people who build efficiently Save this — you’ll use it daily. Focus on thinking. Everything else follows.

I don’t just teach people how to code; I teach them how to build for the real world. 🛠️💻 For Day 2 of our training at Innovempia, I took the backend cohort away from their Python scripts to focus on the one tool that separates a "coder" from a "Software Engineer": Version Control. I watched my students, like Pheetomilechi Ghajiga, move beyond the basics of git add and commit. We went deeper into: Enterprise Workflows: Setting up Branch Protection rules so you literally cannot push broken code to main. Feature Branching: Learning to build in parallel universes so your main project stays clean and stable. Safe Reverts: Because knowing how to undo a mistake is just as important as making progress. Seeing a student get excited about "blocking their own push" because they’ve finally understood how enterprise teams protect production code that’s the Innovempia difference. We aren't just learning syntax; we're mastering the professional standards of 2026. 🚀🦾 Are you ready to level up your engineering workflow? Join us now..it is not too late. 📞 Enquiries: 08066008669 🌐 Register: www.innovempia.com/courses #SoftwareEngineering #Git #GitHub #Innovempia #Mentorship #AbujaTech #BackendDevelopment

Backend/dev progress update: Integrated Tailwind CSS into my Django project and got live auto-reload working. Sounds simple on paper. Wasn’t simple in practice. What it actually took: • Configuring Tailwind with Django properly • Debugging broken builds / static file issues • Restarting the dev server more times than I can count • Tracing errors until everything finally clicked Best part of the day: Watching styles auto-update instantly after changes once the pipeline was set up correctly. Big reminder: A lot of development progress doesn’t come from writing new features— it comes from debugging configuration until the tooling works. Every setup issue forced me to understand the stack better instead of just copying commands. Thinking of adding some Linux learning alongside this next, since understanding the environment developers work in seems increasingly important. #BackendDevelopment #Django #TailwindCSS #WebDevelopment #Debugging #Python #LearnInPublic #SoftwareEngineering

Doqtor is learning a new language. You can now use Doqtor to keep your Python documentation in sync with your code. Automatically detect changes in functions and classes in .py files and update your READMEs and docs. Expanding the ecosystem to help even more developers keep their documentation honest. Check it out: https://lnkd.in/gqbrCNir

Laziness: the underrated superpower of every programmer. Built a small CLI tool that kills the most boring part of starting a new project. The problem: Every new project means the same manual steps — configuring ESLint, Prettier, Husky, commitlint, wiring scripts, setting up git hooks. Easy to misconfigure. Always time-consuming. The fix: One command, a few prompts, and your project is ready — → Asks a few interactive questions → Scaffolds your entire project structure → Sets up only the tools you actually want → Wires everything together automatically TypeScript supported now. Python on the way. Code: https://lnkd.in/dJvFfHVm The only thing I repeat is "I should automate this." #BuildInPublic #CLI #TypeScript #DevTools #OpenSource #DeveloperExperience

📦 Understanding git add . vs git add README.md When working with Git, staging your changes is a key step before committing. Let’s break down these two common commands 👇 🔹 git add . (Add Everything) git add . Stages all changes in your current directory Includes new, modified, and deleted files Best when you want to commit everything at once 🔹 git add README.md (Add Specific File) git add README.md Stages only one file (in this case, README.md) Useful when you want more control over what gets committed Helps avoid committing unwanted changes 🔹 When to use what? ✅ Use git add . → when your changes are clean and ready ✅ Use git add <file> → when you want selective commits 💡 Pro Tip: Always run: git status before committing to see exactly what’s staged. Mastering staging = cleaner commits + better projects 💯 #Git #GitHub #Programming #Developers #CodingTips #Python #WebDevelopment

Today I finally understood Docker in a practical way . Now I understand the core idea: Docker helps us package our app + dependencies + runtime environment so it runs the same way on any machine. What clicked for me: ~ Image = blueprint ~ Container = running instance of that image ~ Dockerfile = recipe to build the image Lets understand this with a simple example I have a project built with Python, NumPy, Pandas, and other libraries. [ Without Docker ] --> My friend must install Python --> Then install all required packages --> Then match versions --> Still may face setup errors [ With Docker ] --> My friend only needs Docker --> Build image --> Run container --> App works with all dependencies already packaged inside One more thing I learned: Containers do take disk space, but they are still considered lightweight compared to full virtual machines because: They share the host OS kernel They reuse image layers efficiently Also understood why teams use separate containers for frontend, backend, and database: Docker is not just a tool. It is a reliability mindset for development and deployment. Still learning, but this was a unlock for me . #Docker #DevOps #SoftwareEngineering #LearningInPublic #BeginnerDeveloper #TechJourney

"Thou shalt not make unto thee any graven image"(c) Well, I won't. But I still eager to follow the best practices in software engineering (aside all other areas) to create robust, effective and user-friendly systems that help business to solve problems instead of multiplying it. Talking about good role models: guys from wemake-services team have just made another state-of-the-art solution, this time for Django-based REST API development. It is fast, flexible, but still rigorous about data quality controls. I do not tell that you should drop DRF or django-ninja from your existing code immediately, but definitely advice to consider DMR as an alternative for your future projects :) #Python #Django #DRF #REST https://lnkd.in/dNsZu8u9

🧠 "The gap between tutorials and real-world code is real." In Django tutorials: perfect views, neat serializers, everything "just works." In my project: messy, duplicated, ugly. I used to think it was my skill. Now I realize: tutorials don't show refactoring, or coping with 60% understanding, or building something good enough for today. So I shifted my goal: From "write code that looks like a tutorial" To "write code I can confidently change later." That means accepting early mess, leaving clean interfaces, and commenting for future-me. Tutorials show the polished result. Real learning happens in the uncomfortable middle. 👉 What does your codebase do that no tutorial shows? #WebDevelopment #Django #BackendDevelopment #LearningInPublic #CodePractice

The Git Problem Everyone Knows. At some point, every project ends up looking like this: - fix stuff - update code - final version - bug fix - changes And somehow… nobody really knows what happened. I used to do this too. It works when you’re alone, but as soon as a project grows, it becomes a real problem. You lose clarity, you lose history, and debugging becomes painful. That’s when I discovered Conventional Commits. Instead of writing random messages, each commit follows a structure: - fix(auth): resolve login crash when password is empty - feat(ui): add loading spinner to login button - refactor(api): simplify user validation logic Now, in one line, I know: - what changed - where it changed - why it changed It seems like a small detail, but it completely changes how you read and understand a project. To make it easier to apply, I also use Commitizen, which guides commit creation and enforces the standard. Clean history is not a luxury. It’s part of building reliable systems. To see the full blog post: https://lnkd.in/exgJ4_mP #KubeCraft #DevOps #Git #BestPractices #DevSecOps