# John Athayde: Maintaining the User Side of Software

EP-227 | September 8, 2026 | 01:22:19




The user interface of a long-lived application carries years of technical decisions, design choices, and organizational history. John Athayde joins Robby to explore how teams can untangle that front-end sprawl, and what changes when AI makes it much easier to analyze and rewrite what came before.





## Show Notes

Software maintainability is often discussed through the codebase, but users experience years of accumulated decisions through the interface. [John Athayde](https://www.johnathayde.com/) of [Meticulous](https://meticulous.com/) joins Robby to examine maintainability from the front-end and product-design side, starting with documentation and the context it preserves for future teams.

John describes how older applications accumulate multiple UI libraries, generations of CSS, inconsistent components, and different interaction patterns. Improving these systems does not always require a redesign. Sometimes the more valuable work is removing dependencies the browser no longer needs, consolidating patterns, and understanding which unusual workflows users still depend on. They also explore how design systems can become part of a maintenance strategy, provided teams treat them as products that require governance and restraint.

Later, Robby and John turn to AI. John is using AI tooling to audit applications, find repeated patterns, remove old dependencies, expand tests, and reconstruct requirements from existing code. These tools can make software archaeology and large-scale changes much faster, but speed does not replace judgment. The challenge is understanding what should change, what needs to remain, and whether today's faster implementation is creating software tomorrow's team can still maintain.

## Topics

- [00:02:00] **Documentation as a Sign of Maintainability:** Why documentation and evidence of ongoing care matter when entering an existing codebase.
- [00:07:02] **Maintainability From the User's Side:** Dated interfaces, usability, and replacing old dependencies with modern browser capabilities.
- [00:11:22] **Making the Case for Cleanup:** Connecting technical cleanup to development speed and the ability to ship future features.
- [00:13:27] **Bringing Coherence to Operational Software:** How products accumulate different interfaces and patterns through years of development and acquisitions.
- [00:19:14] **Finding the Why:** Discovering how software is actually used before deciding what should change or disappear.
- [00:24:44] **Knowing When to Remove Things:** Product ownership, sunsetting features, and the organizational politics of taking functionality away.
- [00:34:05] **Why Designers Should Understand Code:** How technical fluency helps designers and UX awareness helps developers.
- [00:39:00] **Choosing Tools in Service of the Product:** Balancing new frameworks and experimentation against what a team can maintain.
- [00:47:19] **Design Systems as Maintainable Products:** Tokens, components, governance, and auditing years of accumulated UI decisions.
- [00:51:39] **Using AI for Front-End Archaeology:** Applying AI and static analysis to find patterns, remove dependencies, and investigate old applications.
- [01:04:00] **Rewrite or Refactor in the AI Era?:** How tests, captured requirements, and AI-assisted development may change the economics of rewrites.
- [01:14:20] **Where AI Still Needs Human Judgment:** Why faster implementation does not eliminate difficult product and engineering decisions.

## Thanks to Our Sponsors!

Your test coverage says 90%, but that might be misleading. [Undercover CI](http://undercover-ci.com) looks at your Ruby pull requests and shows you which parts of your changes weren't tested- not just overall coverage, but what changed and what got missed, down to the method level. Visit [undercover-ci.com](http://undercover-ci.com) and use code **MAINTAINABLE** for 15% off your first billing cycle. Free for public repos. Private repos with unlimited users also available.

[Mailtrap][Mailtrap](https://l.rw.rw/maintainable_2) is a modern email delivery platform built for developers. Native SDKs, a secure Email API and SMTP, and a free tier with 4,000 emails a month. When you need help, you'll reach real people on 24/7 support, not an AI chatbot. [Try Mailtrap for free!](https://l.rw.rw/maintainable_2)

## Links & Resources

- [John Athayde](https://www.johnathayde.com/)
- [Meticulous](https://meticulous.com/)
- [John Athayde on LinkedIn](https://www.linkedin.com/in/johnathayde/)
- [John Athayde on Bluesky](https://bsky.app/profile/johnathayde.com)
- [John Athayde on X](https://x.com/johnathayde)
- [John Athayde on Ruby Social](https://ruby.social/@johnathayde)
- [_The Timeless Way of Building_ by Christopher Alexander](https://www.patternlanguage.com/)
- [_A Pattern Language_ by Christopher Alexander, Sara Ishikawa, and Murray Silverstein](https://www.patternlanguage.com/bookstore/pattern-language.html)
- [The Phoenix Architecture by Chad Fowler](https://aicoding.leaflet.pub/)
- [Ruby on Rails](https://rubyonrails.org/)
- [Axe-core](https://www.deque.com/axe/axe-core/)
- [Herb, HTML+ERB tooling by Marco Roth](https://herb-tools.dev/)








## Transcript