Issues like “technical debt”, “tight coupling”, poor “cohesion”, and “incidental complexity” are killing your agile team’s ability to deliver effectively, which in turn is killing your bottom line, and their morale.
As an Agile Technical Practices Coach, I teach and coach developers what bad code looks and smells like. My 8-week Craftsmanship program is a great way to build up baseline skills and smooth out the flow of value from your team. Let me show you what your organization looks like through my lenses.
How Does It Happen?
One line of code at a time.
In the beginning, while things are uncomplicated, features will fly out the door. We push towards that “Minimum Viable Product,” something our users can actually use.
Then, it starts to get more complicated. Technical decisions are made in the code that everyone thinks are a good idea, because they probably were a good idea. Then, over time, they start to work against the team, resisting change. And then over time, it gets worse.
Tension causes folks to cut corners, make assumptions, jury rig, throw people at it, do whatever it takes to “just get the d**n thing finished.”
Software development has shifted considerably in the past 20 years. We’ve moved from shipping “finished” software on discs every 6-24 months to delivering works-in-progress instantly.
Developers are being forced to live with the code they write over the long term, rather than handing it off to another team for “maintenance”. Adding to it and changing it constantly according to the needs of the business.
Despite how great your application may look on the surface, your developers know what it’s like to live with that code.
You start hearing things like “this needs to be rewritten,” “we don’t have time,” the time it takes between customers asking for something and your team finally delivering it seems to continually grow. You try adding people. You try outsourcing. Adding capacity should have helped, shouldn’t it?
Writing code or building a product that never becomes “finished” is done very differently, and people just aren’t taught how to do that. We’ve never expected them to do that in the past.
Start Making a Difference
Modern agile technical practices have been evolving for decades to help us with this, but are still largely misunderstood, misapplied, or even ignored altogether.
New graduates have been taught theory and skills that may have been useful 20 years ago, but are woefully inadequate today.
In modern agile software development, we use terms like Technical Debt, Coupling, Cohesion, and Incidental Complexity. These terms come from the reality of what we face in the code we write every day.
These issues are addressed through modern technical practices like test-driven development, refactoring, and the practiced understanding of a few basic principles.
Your team needs your help to make this all work, and I designed this program to get you started on the path.
It doesn’t matter if your organization subscribes to any particular flavour of agile development practices, but it should have some practices in place to address communications and build common understanding. You can use SAFe, Scrum, LESS, DAD, it doesn’t really matter as long as you have some system in place for managing communications and change.
The practices I teach are what your team needs to keep up at their keyboards. My program is specifically designed to speak to them on their level, to help them build software that is easier to understand, easier to change, easier to build upon, and less disrupted by the technologies around it.
Interested? Drop me a line, let’s start a conversation.
Sign up below to receive a copy of our white-paper that describes the approach we take to building a healthy developer culture within your team.