Sound Familiar?

• the team’s working long hours but still missing deadlines?
• fixing bugs just causes more bugs?
• it takes forever to get the simplest new features into the hands of your users?

Issues like “technical debt,” “tight coupling,” weak “cohesion,” and “incidental complexity” are killing your agile team’s ability to deliver efficiently, which in turn is killing your bottom line and their morale.

As an Agile Technical Practices Coach, I teach and coach developers to recognize the look and smell of bad code. My 8-week Craftsmanship program is an excellent way to build up baseline skills and smooth out the flow of value from your team. Look at your team through my lenses for a while to find new ways to build efficiency.

How Does “Bad Code” 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 use, and there is little friction to getting things done.

Then, it starts to get more complicated. Developers make decisions that seem like a good idea at the time. Then, those decisions start to work against the team, the code resists change. And then over time, the friction gets worse. New features and updates come slower and slower.

The building 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.”

Does this sound like your team?

The Problem(s)

Despite how great your application may look on the surface, your developers know what it’s like to live with that code.

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 in seconds.

Rather than handing the code off to another team for “maintenance,” developers today must live with it over the long term. They add to it and change it continually according to the needs of the business. Coding should have always received this level of discipline, but our old insular silo approach to development let developers push the stink off to where they didn’t have to smell it.

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 continually grows. You try adding people. You try outsourcing. Adding capacity should have helped, shouldn’t it?

Start Making a Difference

Modern agile technical practices have been evolving for decades to help us with this, but are still rarely taught, are widely misunderstood, misapplied, or ignored altogether.

In modern agile software development, we use terms like Technical Debt, Coupling, Cohesion, and Incidental Complexity. These ideas reflect the reality of what developers face in the code they write every day.

Developers address these issues by adopting technical practices like test-driven development, refactoring, and the practiced application 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.

The methods 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 simpler to understand, easier to change, easier to build upon, and less disrupted by the technologies around it