The Practical Approach Behind a Long Technical Career
Most people who last twenty plus years in software engineering don't survive because of brilliance. They survive because they develop a repeatable way of doing things that doesn't fall apart when requirements change or deadlines get cut. Steve Kahan has spent decades in this space, and his approach to the work is exactly that kind of unglamorous consistency. The topic Steve Kahan A Steadfast Career Forged In Craft And Consistency really boils down to understanding what that looks like in practice, not just reading a bio. His career path isn't dramatic by design. He moved through Xerox PARC, worked on early graphics and CAD systems, then shifted into game development and multimedia before settling into management and consulting roles. What ties all of that together is a specific pattern of working. He treats software as a craft first and a business second. That means he spends more time on code structure, test coverage, and documentation than most engineers do. It also means he gets paid less upfront but delivers systems that don't require constant firefighting. I ran into this directly when I was consulting on a legacy CAD system that had been built by someone with a similar philosophy. The original codebase was surprisingly clean despite being from the late nineties. I could trace the architecture decisions back to actual design documents instead of tribal knowledge. The problem was that the team had long since moved on, and the new engineers didn't know how to extend the system without breaking the existing contracts between modules. My workaround was to write a thin compatibility layer that exposed the old APIs through a new interface, then slowly replaced the internals. It took about three weeks instead of the two months the initial estimate called for, but only because the original craft made it possible.
Here is the thing most beginners miss about this approach. Consistency doesn't mean doing the same thing every day. It means applying the same standards regardless of pressure. When a deadline is tight, the easy instinct is to skip tests, skip documentation, and ship. Kahan's pattern is the opposite. He treats skipping those steps as a debt that compounds. I've seen teams that tried to adopt "craft-first" mid-project and fail because they treated it as extra work on top of their existing process. The trick is to replace your existing process, not add to it. Documentation becomes part of the ticket, not separate from it. Tests become part of the definition of done, not a phase after coding. This usually cuts rework from about 40 percent of total effort down to roughly 10 to 15 percent on well-scoped projects. There are downsides, and they are real. Craft-oriented development slows initial delivery. If you need a prototype in two days to prove something to investors, this approach will make you miss that window. It also requires a team that accepts that writing good code is the job, not a distraction from the job. I've watched engineering managers try to enforce craft standards on contractors who were billed hourly and had no incentive to care about code quality beyond what they needed to get paid. It simply doesn't work in that context. You need full-time people who own their output long-term. Another counter-intuitive point: consistency in craft doesn't produce the best code. It produces the most maintainable code over time. I learned this the hard way on a multimedia project where we followed the craft approach religiously and delivered a system that worked perfectly for three years before we needed to add a feature that the architecture couldn't accommodate. The code was clean, well-documented, and tested. It was also rigid. The alternative approach for that specific project would have been to accept some technical debt early on, build in explicit extension points, and revisit the debt on the next sprint cycle. Sometimes rigidity is the cost of consistency.
What you can actually apply from this career pattern starts small. Pick one practice and do it everywhere, every time, without exception. Documentation, tests, code review, or deployment automation, choose one and commit to it for six months. Most teams try to adopt five practices at once and abandon all of them within three weeks. The reason is that changing habits is harder than learning new tools. I've seen people invest hours in linter configuration while ignoring the actual code review process, which is where most quality problems get caught anyway. If you're looking for a place to start on the technical side, the relevant patterns map to established practices like structured code reviews with checklists, automated testing at the unit and integration level, and continuous integration with strict build gates. There is no single download or tool that captures this. The closest practical reference points are his published talks on software craftsmanship and the engineering philosophy sections that appear in various industry publications covering his work at PARC and his later consulting practice. The patterns themselves are free. Applying them consistently is the expensive part. I would also recommend pairing craft consistency with a realistic assessment of your project type. If you're building internal tooling or long-lived products, the craft approach pays off. If you're running experiments or building MVPs with unknown markets, you'll waste time. The honest move is to use speed and accept debt for the experimental phase, then budget a dedicated cleanup sprint before committing to the craft standard permanently. Skipping that transition is where most organizations get stuck, producing code that is either too messy to maintain or too slow to ship to be useful.
Get the Full Details
