If it is not done in source-control, it is not worth doing
Anything that lives outside source control is invisible by default. It is critically important to include every single piece of work that constitute our system in our source control tool.
Hello, developers! 🚀
Welcome back to the Learn Agile Practices newsletter, your weekly dose of insights to power up your software development journey through Agile Technical Practices and Methodologies!5t
Before starting, I quickly remind you that my brand new Test-Driven Development 101 5-day Email Course is available: it is the introduction to TDD I wish I had when I started learning it, so I think you will find it very useful!
As a subscriber to my newsletter, you can have it with a 10EUR discount! 👇
Now, let's dive into today's micro-topic!
In short
💻 Source control has transformed software development. The introduction of such systems has allowed for better collaboration and more organized development processes.
📂 Source control is not just for code. Everything related to a software system should be included. Without it, these components remain invisible.
🔄 Modern development relies on source control for much more than just code, for example: tracking changes, collaborating asynchronously, automating tests, and so on. Everything important should be in there.
Everything should be source controlled
Before modern version control systems like Git, Subversion, and even CVS existed, development teams worked under much less efficient and riskier conditions. There was no central repository where changes could be tracked, and no automated system for managing versions of code. Instead, developers would manually manage their changes, often leading to issues of overwritten code, lack of history, and difficulties coordinating among team members.
The advent of source control revolutionized the software development process, making it possible to collaborate more effectively, track every change, and work on different parts of a project simultaneously without fear of overwriting someone else’s work. This shift allowed teams for more efficient, organized, and error-free development processes, ultimately changing the way software is built and maintained today.
Today, it is clear that anything not stored in source control lacks visibility, collaboration, and accountability. It is critically important to include in our centralized versioned history every single piece of work that is part of our system.
If it’s not done in source control, it’s not worth doing.
Source control is not just about saving your code. It’s about collaboration, accountability, and trust. When you version your work, you create a timeline. You expose decisions. You enable change.
That applies not only to source code, but also to everything that defines and supports a software system:
Deployment scripts
CI/CD pipelines
Database migrations
Infrastructure as code
Feature flags
Test plans
Documentation
Architecture diagrams
Anything that lives outside source control is invisible by default. That makes it fragile, tribal, and risky.
To be honest, I also have a problem with the name "VCS" (Version Control System) for being co-opted by vendors and prefers the simpler and more grounded "source control," following the same rationale Linus Torvalds had in coining Git.
The focus is clear: this is about managing source code, not just versions.
Not configuration. Not bureaucracy. Source code.
This isn’t gatekeeping. It’s about professionalism.
A modern development team must be able to:
Reconstruct any previous state
Roll back safely
See who changed what, and why
Collaborate asynchronously
Automate reviews, tests, and releases
Track intent and history, not just code
None of this is possible without source control. And doing work outside of it introduces invisible liabilities.
👉 That feature branch you're working on but haven’t pushed?
👉 That onboarding doc you wrote but saved only locally?
👉 That YAML config you tweak manually in production?
It's not worth doing if no one can see it, share it, or repeat it.
So yes, be bold: put everything in source control. And then make it the foundation of your development culture. That’s not just technical hygiene—it’s a strategic enabler of agility.
Until next time—happy coding! 🤓👩💻👨💻