New data, old chats and graphs.

What happens when you need updated graphs from a bunch of chats?
New data, old chats and graphs.

The Evolution of AI-Assisted Board Presentations: From Quick Wins to Sustainable Processes

Like many technology leaders, I've been exploring ways to leverage AI to streamline our workflows. Recently, I learned a valuable lesson about the difference between using AI for quick wins versus building sustainable processes. Here's what happened.

The Quick Win That Taught Me Better

A month ago, I was preparing for a board meeting and needed some data visualizations. Like any technologist with a new tool, I jumped right in - dropped some data into Claude, asked for graphs, and walked into the board meeting with some impressively polished visualizations. Success, right?

Well, fast forward to today. Another board meeting approaching, new data to present, and all I had were my old prompts and outdated data. That's when it hit me - I had optimized for speed at the expense of sustainability.

Rethinking the Process

Instead of just fixing the immediate problem, I saw this as an opportunity to build something better. I started fresh, but this time with a different approach:

  1. First, I asked Claude to export its visualization styles and design hints as reusable specifications
  2. Then, I moved to VSCode and partnered with Cline to build a proper project structure
  3. Most importantly, I set clear context upfront: "We're creating a project for visualizations of data, with both data and scripts so they can change over time independently"

The key shift in my thinking was moving from "make me some graphs" to "let's design a system for creating and updating graphs." This subtle but powerful change in approach reflects something I've learned over two decades of building systems - the initial solution is just the beginning of the story.

The Power of "Let's Make Some Specs"

One habit change that's made a massive difference in my AI workflows: starting with specifications instead of jumping straight to implementation. When working with AI, it's tempting to ask for immediate results. But I've found that saying "let's make some specs" creates a natural pause for reflection and design thinking.

This approach has several benefits:

  • It creates clear documentation that can be versioned and shared
  • It allows for review and refinement before implementation
  • It makes it easier for others to learn from and contribute to the process
  • Most importantly, it builds institutional knowledge that evolves with your needs

The Proof is in the Process

Within about two hours, I had transformed my one-off visualizations into a data-driven system, complete with scripts and documentation. Everything was pushed to GitHub, including the AI conversation history - creating a learning resource for the team.

The real test came the next day when I needed to add DORA metrics visualizations. Instead of starting from scratch, I simply:

  1. Dropped the new CSV into our data folder
  2. Told Cline I wanted to add visualizations for that data

The system we had built was so robust that Cline not only recognized the DORA metrics format but took the initiative to add industry benchmark lines to the graphs - a detail I hadn't even considered.

The Bigger Lesson

The key insight here isn't just about building better board presentations - it's about how we approach AI tools in our development workflows. The mantra I've adopted is simple: "Don't ask AI to do; ask AI to think about it, write it down, then do."

This mirrors the best practices we've developed in software engineering over decades. We don't just write code - we plan, document, review, and iterate. As we integrate AI into our workflows, we need to bring these same principles forward.

For my fellow technology leaders: as you explore AI tools, consider how you can build processes that don't just solve today's problems but create foundations for tomorrow's solutions. The extra time spent on thoughtful design pays dividends in sustainability and scalability.


This post is part of my ongoing exploration of integrating AI tools into enterprise technology workflows. These are lessons learned from real implementations, shared to help others navigate this rapidly evolving landscape.

Share This Article

Related Articles

Post Comments