Building Custom AI Developer Tools for Enhanced Productivity

The future of software development is not about writing more code, but about orchestrating AI to write it better, faster, and with fewer hidden costs. This conversation with CJ Hess reveals a critical, often overlooked consequence of the AI revolution: the imperative to build custom developer tools. While many focus on the models themselves, Hess demonstrates how crafting bespoke workflows and visualization tools unlocks a new level of productivity and code quality, particularly for complex tasks like UI design and system planning. This insight is crucial for engineers, product managers, and CTOs who want to gain a significant competitive advantage by moving beyond generic AI tools and developing their own intelligent development environments. The advantage lies in creating a personalized, efficient system that directly addresses unique development challenges, a feat that requires embracing the discomfort of building rather than just consuming.

The Hidden Architecture of AI Development: Beyond Generic Tools

The rapid evolution of AI models has sparked a gold rush, with many developers eager to leverage the latest advancements. However, CJ Hess, a software engineer at Tenex, argues that the true power lies not just in the models themselves, but in the custom tools and workflows built around them. This perspective challenges the conventional wisdom of relying solely on off-the-shelf solutions, suggesting that building bespoke AI developer tools offers a profound, long-term advantage by enabling deeper intent understanding and more efficient problem-solving.

Hess's approach centers on extending the capabilities of AI assistants like Claude Code. He highlights how the "steerability" and "intent understanding" of Claude Code, combined with custom-built "skills," have allowed him to create a personalized ecosystem that significantly enhances his development process. This goes beyond simply using an AI to write code; it's about shaping the AI's interaction with the development environment itself.

"Maybe I'm not giving Opus and Cursor the shot it deserves here, but there's something about Claude Code, when I wanted to dig deep, it just does it. It feels to pick up on my intuition just in the prompts, and it's really enabled me to almost build a little ecosystem of my own tools around it, around Claude Code, particularly with skills now, that just keep making it better and better for me because it's Claude Code plus this system of skills and tools that I've built around it."

This quote underscores a key consequence: the ability to build these tools bypasses the limitations of generic IDEs and AI integrations. Hess explains that traditional developer environments offered customization, but AI now allows for a fundamental reimagining of the workflow. This means individual engineers can develop highly personalized, efficient workflows that might differ significantly from their colleagues, yet still yield superior results. The low cost and rapid development cycle for these tools further incentivize this "build-your-own" approach, removing the traditional barriers to adopting new development infrastructure.

The Visual Divide: From ASCII Diagrams to Interactive Mockups

One of the most compelling examples of Hess's custom tool development is "Flowy," a visualization tool designed to overcome the limitations of text-based planning. While AI models can generate ASCII diagrams for flowcharts and UI mockups, Hess found them cumbersome and difficult to interpret. The subtle misalignment of characters and the inherent lack of visual fidelity made them a bottleneck in the design process.

"But the one piece that I hated that I found really valuable was these ASCII flowcharts. So if you're just listening, it's all those like boxes and arrows that Claude draws. And, you know, there's always the ones where, this one actually looks pretty clean. Yeah, there's always this like misalignment of that edge character. I don't know why we haven't figured that out yet. But for things like UI mockups, things like, you know, flowcharts of how navigation is going to work, how a certain system is going to work, I really like this visual way to think about things, but I really hate staring at these ASCII diagrams."

Flowy transforms these limitations by converting JSON files into interactive visual mockups and flowcharts. This not only makes the planning process more intuitive but also creates a shared, visual language between the developer and the AI. The ability to edit these visuals directly within Flowy, which then updates the underlying JSON, creates a dynamic feedback loop. This is a significant departure from static Markdown plans; it's an AI-native approach to design and planning. The implication is that as AI models become more capable, our expectations for their output must evolve. What was once impressive--ASCII diagrams--quickly becomes insufficient. Building tools like Flowy allows developers to stay ahead of this curve, ensuring that the AI's output remains useful and actionable.

The "Vibe-Coded" Ecosystem: Skills as Living Documentation

Hess's development of Flowy is rooted in his creation and refinement of "skills" for Claude Code. These skills act as specialized agents, trained to understand specific tasks and data formats, like the JSON schema used by Flowy. The process of building these skills is iterative and, as Hess describes, often driven by necessity. When something goes wrong, he updates the skill, treating it as a form of "living documentation" for both humans and AI.

"And incrementally, I've been building that up where if I'm working with this and something goes wrong, almost an example here would be this like white text on these, you know, pastel notes, kind of hard to read. I would essentially hop into the place where I have these skills and say, here's what happened, give me a suggestion on how to improve this skill so this doesn't happen again. And then iteratively just keep building that skill."

This approach highlights a critical long-term advantage: a codebase that is not only functional but also deeply understood and managed by the AI. By updating skills alongside code development, Hess ensures that the AI can consistently interpret and interact with his tools. This creates a robust feedback loop where the AI's performance improves as the tools evolve. The alternative--relying on generic prompts or models that lack this specialized understanding--leads to a gradual degradation of quality and efficiency as complexity increases. The "vibe-coding" of these skills, as Hess puts it, allows for rapid iteration and adaptation, a stark contrast to the slow, deliberate pace of traditional software tool development.

Model-to-Model Review: The Curmudgeonly Staff Engineer

Beyond visualization, Hess employs a sophisticated code review process using a "model-to-model" comparison, pitting Claude Code against Codex (referred to as "Carl"). This isn't about finding simple bugs; it's about identifying code smells, architectural improvements, and ensuring the generated code aligns with broader best practices--tasks often associated with experienced, critical human engineers.

"I almost want to look for like the code smells, like, you know, is there just a cleaner way? So I usually just prompt it with, take a look at our current Git diff and give me a report on the following. And there's kind of four buckets, I would say. One, for the plan or diagram artifacts we have, does the code accurately reflect them? Two, are there any general code smells? And three, if we were to do this again and take a different approach to refactor code around it to to overall improve this codebase, what approach would be best?"

This strategy addresses a significant downstream consequence of rapid AI code generation: the potential for technical debt and architectural inconsistencies. While AI can be incredibly fast, it can also be "eager," as Hess notes, sometimes producing code that works but isn't maintainable or scalable. By using a second model for review, Hess introduces a layer of critical evaluation that complements the generative capabilities of the primary model. This is where immediate pain (the effort of setting up and running a second model review) creates lasting advantage (a cleaner, more robust codebase). It’s a proactive approach to quality control that scales with the speed of AI development, preventing the accumulation of "vibe-coding sins."

Actionable Takeaways

• Embrace "Build, Don't Just Buy" for Dev Tools: Identify repetitive or cumbersome parts of your AI development workflow and consider building custom tools or "skills" to streamline them. This offers a significant competitive advantage over relying solely on generic solutions.
• Develop Visual Planning Workflows: Move beyond text-based plans. Invest time in creating or adapting tools that generate interactive flowcharts and mockups, fostering clearer communication between you and your AI agents.
• Iteratively Refine AI Skills: Treat your AI "skills" as living documentation. Continuously update and refine them based on your usage, ensuring your AI agents understand your custom tools and evolving requirements.
• Implement Model-to-Model Code Review: Use a secondary AI model to review code generated by your primary AI. Focus this review on code smells, architectural consistency, and potential refactoring opportunities, acting as a "curmudgeonly staff engineer."
• Prioritize Long-Term Code Quality: Accept that AI-generated code might require an extra layer of review to prevent technical debt. The effort spent now on cleaner code will pay dividends in reduced maintenance costs and increased development velocity later.
• Experiment with "Dangerous" Permissions (Safely): In controlled environments or for personal projects, explore bypassing standard permissions to speed up development cycles, as Hess does with his "bypass permissions" alias. Understand the risks and implement safeguards where necessary.
• Leverage AI for Planning and Refactoring: Use AI not just for initial code generation but also for creating detailed plans, refactoring existing code into more scalable structures, and generating code that reflects desired architectural patterns.

This blog post is based on the podcast episode "How to build your own AI developer tools with Claude Code | CJ Hess (Tenex)" from the "How I AI" podcast.