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, jerry-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


Part of a Balanced Agile Transformation

While setting up your processes to smooth the flow of value from inception to delivery, build developer skills that will result in a more flexible and adaptable codebase.

3 Levels of Learning

1h weekly instructor-led training, plus 1h weekly of facilitated practice of the content, plus 2-3 one on one coaching sessions with key staff, packed into a single site visit.

Followup and Reinforcement

Every session is followed up by a refresher quiz and individualized report based on each person's answers. Every session is preceded by a "temperature check" to measure change.

Strategic Feedback

Learn about the friction the team is feeling, and help the team understand the friction you're feeling, so that together we can find ways to smooth out the flow of value and build trust.

Stacey's Latest Musings

Thoughts on business and software development

Group Kata Facilitation

This is my fall-back group format when facilitating kata. Timeframe: 60m total – 45-50m exercise, 10-15m retrospective Group Size: 6-16 participants (3-8 pairs) Room Setup: one laptop per pair, optional projector or TV for kata Read more…

Pair Chain Exercise

When I facilitate a kata session with a group of developers, sometimes I like to mix it up a little. If the room feels like it’s getting a little bored of a format, or if Read more…