Introduction: “Wait, Do I Really Need Diagrams in 2025?”
Let’s be real. In 2025, AI is everywhere, sometimes it feels like it’s doing half our jobs, sometimes it feels like it’s making us dumber (there are lots of arguments on this 2 sides of the coin when you get on LinkedIn or Facebook). There are two sides to using AI for BA/PO/PM work: some say too much AI gives you “brain rot,” others say it’s the best productivity boost ever—if you stay in control and know what you’re doing. I’ve seen both.
when you don’t want to explain a messy spec
Here’s a true story: I was in a meeting with engineers and a QA, trying to explain how a Lucky Spin game feature actually runs on front end, back end, calculations, and event intervals. Everyone was nodding, but their eyes said, “WTF is going on?” Words failed. Docs didn’t help. I drew a quick diagram, and suddenly, everyone kind of got it. From then on, for any feature that’s hard to explain, I use diagrams. Diagrams bring everyone to a shared understanding much more quickly than words alone.
Why does this matter more than ever? Because diagrams let you focus on the big picture and strategy, not just the nitty-gritty. With AI, you can generate diagrams, code, and specs faster—but only if you give the right context. The tool is only as good as your prompt. If you’re lazy or unclear, you’ll get garbage. If you’re thoughtful, you’ll get leverage.
Visual: Lucky Spin Game Sequence (using PlantUML)
@startuml
actor User as "Người chơi"
participant FE as "Frontend (Web/App)"
participant BE as "Backend Service"
participant QA as "QA System"
User -> FE: Tap "Spin" Button
FE -> FE: Disable button, show loading
FE -> BE: Send Spin Request (userId, eventId)
BE -> BE: Validate user, check event status
BE -> QA: Log Spin Attempt (userId, timestamp)
BE -> BE: Check user balance, cooldown, eligibility
BE -> BE: Calculate Spin Result (random, rules)
BE -> QA: Log Result (userId, prize)
BE --> FE: Return Result (prize, message)
FE -> FE: Show Result Modal (win/lose, prize)
FE -> QA: Log UI Event (display result)
FE -> User: Enable button, allow next spin
User -> FE: (Optional) Tap "Spin" Again
FE -> BE: (If allowed) Send Spin Request
@enduml
Why Diagrams Still Matter (Even with ChatGPT, DALL·E, Grok, Copilot…)
Let’s be honest: even with all the AI tools, diagrams are still your secret weapon. Senior folks might say, “I’ve seen every workflow under the sun—why should I care?” Juniors might think, “Isn’t it all just whiteboards and Miro?” But the reality is, diagrams are the fastest way to align a team, especially as remote work explodes.
Humans are visual animals. We drew on cave walls before we wrote books. Diagrams bridge knowledge gaps fast, devs, QAs, designers, even biziness folks. Context is still king, and diagrams are the best way to package and share it.
Context is still king, and diagrams are the best way to package and share it.
Cuong Nguyen
AI enables the generation of diagrams in code (PlantUML, Mermaid, etc.) or by dragging and dropping shapes in tools such as Figma or Miro. But the magic only happens if you give clear, focused context. If you just dump a screenshot or paste in a messy user story, AI will hallucinate or spit out nonsense. If you prep your prompt, you’ll get clarity and save hours of back-and-forth.
Remember: the diagram isn’t just for you. It’s a universal translator. One clean diagram can save you from 1,000 Slack messages or JIRA comments. It’s not about looking smart; it’s about making sure everyone actually understands and be on the same boat with you.
Bonus thought: even ChatGPT, for all its NLP brilliance, often answers better when you ask it to think visually. “Draw this for me” activates a whole different level of clarity.
The 2025 AI Toolbox: From DALL·E to Meme Generators
Alright, let’s geek out. It’s 2025, and diagramming has gotten a turbo boost. The tools are slicker, smarter, and often surprisingly hilarious.
Here are some of the best tools I’ve used in 2024-2025 for diagramming and how they play with AI:
When AI draws something totally wrong
1. PlantUML + ChatGPT
Still the GOAT. Write your diagrams as code. Now, you can just say:
“Create a sequence diagram for user onboarding with OTP verification”
And GPT will write your PlantUML. You can copy-paste and render it in seconds.
@startuml
actor User
participant FE as "Frontend (Web/App)"
participant BE as "Backend Service"
User -> FE: Fill Signup Form
FE -> BE: Send User Info (name, phone, etc.)
BE -> BE: Create Account, Generate OTP
BE -> User: Send OTP via SMS
User -> FE: Enter OTP
FE -> BE: Verify OTP (userId, OTP)
BE -> BE: Check OTP validity
BE --> FE: Verification Success/Fail
FE -> User: Show result (success or error)
@enduml
No design skills? No worries. GPT now handles layout, naming, and logic and can even fix your syntax. It’s like diagramming with a co-pilot.
2. MermaidJS + VSCode or Notion
If you’re a Markdown lover, Mermaid is great. Works directly in Notion and many docs platforms. GPT helps clean syntax and offers block-level suggestions too. Bonus: GitHub renders Mermaid natively now.
3. Lucidchart AI & Miro Assist
Lucidchart and Miro are adding AI co-pilots that help create diagrams from natural language prompts. Visual, collaborative, and great for workshops. Cons? Can be buggy or require some cleanup. Great for PMs working with distributed teams.
4. DALL·E 3 or Sora + Memes for Explainers
Use AI image generators like DALL·E to generate:
- Wireframe concepts
- System architecture mockups
- Funny diagrams (“a developer debugging inside the matrix”)
- Moodboards for stakeholder presentations
Use this not just for show-and-tell, but also for onboarding decks or alignment meetings with stakeholders who hate text-heavy documents.
Example Prompt:
“Isometric illustration of a modern SaaS architecture with microservices, user interactions, and cloud infrastructure. Add a Vietnamese PM with an áo dài and a cup of cà phê sữa đá, and a team collaborating around a table with sticky notes.”
5. Custom GPTs & Prompt Workflows
I built a GPT bot that ONLY writes Mermaid and PlantUML. You give it context, it asks you follow-ups before drawing. Think of it like your junior BA assistant. It’s incredibly useful when you’re spinning up a PRD and need a quick diagram to anchor your requirements.
Pro Tip: Always start your prompt with “I’m a PM working on [X] feature, here’s what I want to explain…”
Even better? Save your prompts as reusable snippets. You can now feed them to tools like Notion AI or Zapier to auto-generate architecture diagrams during sprint planning.
TL;DR AI Toolbox for 2025.
| Tool | Best For | Notes |
|---|---|---|
| PlantUML + GPT | Sequence/system diagrams | Best control, markdown-ready |
| Mermaid + Notion | Quick doc embeds | Great for flowcharts, easy updates |
| Lucidchart AI | Pretty UI, stakeholder demos | Steep learning, $$ |
| Miro Assist | Workshop collab | Great for hybrid teams |
| DALL·E/Midjourney | Wireframe/meme/moodboard | Visual spice |
| Custom GPTs | Your own diagram slave | Build one for your team |
Next level? Combine these tools. Start with a GPT-powered diagram, polish it in Lucidchart, and turn it into a DALL·E-rendered illustration for your next pitch.
Real Life: AI Wins, AI Fails, and the Joy of Chaos
Here’s the messy truth: sometimes AI diagrams are magic, sometimes they’re a disaster. One time I pasted a messy Jira epic into DALL·E and got back a flowchart for making pancakes. Not wrong, but not helpful. Another time, I dumped a whole ticket screenshot into an AI tool and got a wild, isometric illustration that made no sense. It’s easy to blame the tool, but most of the time, the problem was me: I didn’t give enough context, or I was just lazy and pasted the whole thing in.
When AI diagrams go wrong, it’s usually because the prompt was unclear, too long, or missing key info. Sometimes the AI’s knowledge is out of date, or the diagram engine hasn’t been updated. The fix? Don’t be lazy. Take 5 minutes to prep your prompt, clarify your question, and give the AI what it needs. If you’re using ChatGPT Plus, train a custom bot to ask you clarifying questions before it draws. It’ll save you time and headaches.
Tips for blending AI with your own brainpower—when to trust, when to tweak:
- Always check the output for errors or outdated syntax.
- Don’t just copy-paste user stories—summarize the logic first.
- If the diagram looks weird, check your prompt before blaming the tool.
- Use AI as a partner, not a boss. Ask it to explain its logic.
- Keep a folder of “AI fail” diagrams for laughs and learning.
- If you’re stuck, ask the AI to break down the flow step by step.
- Remember: context is king. Garbage in, garbage out.
Diagram Types Every Modern BA/PO/PM Should Know
Let’s get technical: BPMN, ERD, Sequence, Journey maps, C4, and more. Each diagram has its place. You can’t just use the same type for every problem—test them out and see what works for you. For me, sequence diagrams do 70-80% of the job. I also use process diagrams and, for bigger systems, C4 Level 1 or 2. The more you experiment, the more you’ll know what fits where.
AI can “speedrun” each type, but only if you give it the right context. If you’re lazy, you’ll get junk. If you’re clear, you’ll get a shortcut. Here’s a quick table:
| Diagram Type | Best For | Tools | Notes |
|---|---|---|---|
| Sequence | API flows, feature logic | PlantUML, Mermaid | My go-to. Use 70% of the time. |
| Flowchart | Conditional logic, UI flow | Lucidchart, Miro | Easy for non-tech folks to digest. |
| Journey Map | User emotions, UX mapping | Figma, Miro | Good for product discovery. |
| BPMN | Enterprise processes | Bizagi, Camunda | Complex but powerful. |
| ERD | Database models | dbdiagram.io, Lucidchart | Great for dev handoff. |
| C4 (Levels 1 to 4) | System architecture | Structurizr, PlantUML | I usually stop at Level 2. |
Pro tip: The more you sketch by hand first, the more you understand what you need. Don’t jump into tools—sketch, then build. That napkin sketch can save hours.
Example: C4 PlantUML (Level 2)
@startuml
!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml
LAYOUT_TOP_DOWN()
skinparam shadowing false
skinparam defaultTextAlignment center
skinparam wrapWidth 200
hide stereotype
Person(user, "User", "<size:10>Plays Lucky Spin via web or mobile")
Person(admin, "Admin", "<size:10>Manages game settings and views reports")
System_Ext(api, "3rd Party Prize API", "<size:10>Provides external prize data")
System_Boundary(luckySpin, "Lucky Spin Game") {
Container(web, "Web Frontend", "React", "<size:10>User interface for browser users")
Container(mobile, "Mobile App", "Flutter", "<size:10>Mobile interface for Android/iOS users")
Container(apiBE, "Backend API", "Node.js", "<size:10>Business logic, user handling, spin processing")
Container(db, "Database", "PostgreSQL", "<size:10>Stores user data, spin logs, prize info")
}
Rel(user, web, "Uses via browser", "HTTPS")
Rel(user, mobile, "Uses via mobile app", "HTTPS")
Rel(admin, web, "Manages game, views reports", "HTTPS")
Rel(web, apiBE, "Invokes spin, login, prize APIs", "HTTPS")
Rel(mobile, apiBE, "Invokes spin, login, prize APIs", "HTTPS")
Rel(apiBE, db, "Reads/writes user data, spins, prizes", "JDBC")
Rel(apiBE, api, "Fetches external prize details", "HTTPS")
note right of apiBE
<b>Backend Responsibilities:</b>
- Spin cooldown and eligibility
- Randomization and prize allocation
end note
@endumlWant bonus points? Annotate it with roles, timelines, and edge cases.
Quick Start Guide: Up Your Diagram Game with AI (in 2025)
Here’s how I tackle a gnarly spec with AI as my partner (not my boss):
- Start with a messy Slack convo. Pull out the key logic: triggers, flows, outcomes.
- Write a 3-line summary. Don’t just copy-paste—summarize what matters.
- Choose your diagram type. If unsure, pick sequence—it’s universal.
- Prompt GPT or your favorite AI bot. Include inputs, outputs, edge cases.
- Ask for confirmation: “Do you understand the flow?” 50% of errors are skipped steps.
- Tweak and polish. Add error states, user roles, timestamps.
- Paste it into PRD, Confluence, or Slack. Ask your team: “Does this look right?”
- Iterate. Treat diagrams like code—they evolve.
Checklist before prompting:
- Is your feature logic broken into clear steps?
- Can you explain it in plain English?
- Have you picked the right diagram type?
- Do you know your audience (devs, QA, execs)?
- Are there edge cases, exceptions, or fallbacks?
Don’t be like me: sometimes I get lazy and just dump a user story in. Take 5 minutes to prep your prompt and you’ll save hours later.
Prompt Template:
You are a product assistant. I'm a PO working on [feature].
This involves [steps or logic]. Please generate a [diagram type] using [tool].
Include [conditions or variables]. Ask me if unclear.
Checklist Before Prompting:
- Is your feature logic broken into clear steps?
- Can you explain it in plain English?
- Have you picked the right diagram type?
- Do you know your audience (devs, QA, execs)?
- Are there edge cases, exceptions, fallbacks?
Real Example
I recently worked on a “lucky draw” mechanic. Before AI, I’d spend hours sketching, checking edge cases, syncing with devs. Now, I write a summary, ask my AI assistant for a sequence diagram, tweak 2-3 lines, and share.
Diagrams went from chore to shortcut. And my team? Way happier. Less back-and-forth. More alignment.
AI Is Your Diagram Copilot
Treat AI like your junior designer. It won’t replace your thinking—but it’ll make it faster. I use GPT + PlantUML for every spec doc now. It saves me hours. But only when I feed it well.
And remember: diagrams aren’t just for “looking smart.” They’re for solving misunderstandings before they become bugs.
Try it. Laugh at the fails. Share the wins.
Hard Truths, Meme Breaks & What Seasoned Folks Won’t Tell You
Here’s the hard truth: AI can make you lazy or make you look like a genius—it depends how you use it. Some say AI is brain rot, others say it’s a booster rocket. Both are true. If you know what you’re doing and give good context, you’ll get results. If you’re lazy or just copy-paste errors, you’ll get garbage.
I’ve seen devs blame the tool when it spits out gibberish, but most of the time, they didn’t give it enough context. Senior folks still have the edge: they know how to spot impossible diagrams, give the right context, and use judgment. The best AI in the world can’t replace that (yet).
“This is fine” dog in a burning Agile workflow, but the PM is calmly sketching a diagram on a napkin.
Here’s my favorite ‘universal’ PlantUML meme diagram:
@startuml
actor PM as "Product Manager"
participant AI as "AI Bot"
participant Dev as "Developer"
participant QA as "QA"
PM -> AI: <b><color:red>⚠️ Generate diagram for ticket (no proper prompt)</color></b>
AI -> Dev: <b><color:red>⚠️ Output unclear diagram</color></b>
Dev -> PM: "Is this right?"
PM -> Dev: "Not really..."
PM -> AI: Add missing context, retry
AI -> Dev: Clearer diagram
Dev -> QA: "Ready for review?"
QA -> Dev: "Still missing edge case!"
Dev -> PM: "What about error handling?"
PM -> AI: Update prompt with edge case
AI -> Dev: Final diagram
Dev -> QA: "Now test again."
QA -> Dev: "All good!"
' Dev uses AI to code without context (⚠️ Serious Mistake)
Dev -> AI: <b><color:red>⚠️ Write API for /spin (no context)</color></b>
AI -> Dev: <b><color:red>⚠️ Generic code, missing logic</color></b>
Dev -> Repo: Push code
QA -> Dev: <b><color:red>⚠️ API response is weird!</color></b>
Dev -> PM: "What should it return?"
PM -> Dev: "Check the diagram and requirements."
Dev -> AI: Add context, fix code
Dev -> Repo: Push fix
QA -> Dev: "Now it works!"
note right of AI
<b><color:red>⚠️ Warning:</color></b> Using AI without enough context can break your API and confuse the team!
end note
@endumlI’ve printed versions of this and taped them to the office fridge: “Feed me GPT context!”
Cuong Nguyen
Finally, they get it
What I Learned & Why You Should Care
Here’s my honest take after years in tech and riding the AI hype for 2 years:
- AI is here to stay. It’s not going away.
- Use it wisely: give it enough context, and you’ll see how powerful it is.
- Keep up with the trend. Don’t stick to one tool—there’s always something new.
- If you’re too busy to learn, ask yourself why you’re in tech. Tech is about learning and trying new things.
- Don’t be afraid to fail. Every “bad” diagram is a lesson.
- The best diagrams are the ones people draw over and debate in meetings.
- If you want to grow, get comfortable sharing rough drafts and inviting feedback.
- Your brain is still required—AI is just a tool.
If you’ve read this far, here’s my honest truth after hundreds of diagrams, prompts, and coffee-fueled or Trà Sữa spec reviews: There’s no substitute for understanding your product, your users, and the way your own team actually communicates. AI will give you speed and sometimes clarity, but it can’t replace the grind of debugging messy flows, talking to humans, or wrestling with what’s really needed.
Every time I failed, I learned something: prepping your prompt is 80% of the battle, and sharing even “bad” diagrams early saves weeks of confusion. The most valuable diagrams I’ve ever made were the ugly ones people drew over in a meeting, because those got everyone to debate and align.
Here’s my “never forget” visual for why I still draw everything (even badly):
@startuml
actor Team
actor Stakeholder
rectangle UFD as "Ugly First Draft" {
}
rectangle SF as "Shared Feedback" {
}
rectangle FD as "Final Diagram" {
}
rectangle AV as "Archived Versions" {
}
Team --> UFD: 1. Create, scribble, laugh
Stakeholder --> UFD: 2. Ask questions
UFD --> SF: 3. Share for feedback
SF --> UFD: 4. Request changes
SF --> FD: 5. Approve, finalize
FD --> Team: 6. Share clarity, alignment
FD --> AV: 7. Archive version
AV --> Team: 8. Review for next project
note right of UFD
Step 1-2: First messy draft, everyone adds ideas
end note
note right of SF
Step 3-4: Feedback loop: suggestions, critique, iteration
end note
note right of FD
Step 5-6: Clean, agreed diagram for delivery
end note
note right of AV
Step 7-8: Store for future reference and learning
end note
@enduml
Why should you care? Because every product leader I respect, whether they run a startup or a unicorn, still sketches, iterates, and gets messy with their diagrams. The most ‘AI-savvy’ PMs are the ones who use these tools as accelerators, not crutches. If you want to grow, get comfortable sharing your rough drafts and inviting people to roast your work. That’s where learning (and great products) happens.
Even the lady Kế Toán and Google Sheets Have AI Now
Even the old tools you thought would never change are getting the AI treatment. Google just rolled out AI functions for Google Sheets—yes, the same Sheets your company HR, Admin, or the bà cô accountant swears by. Now, you can use the new =AI() function to:
- Generate text (like slogans, summaries, or emails) based on your data.
- Summarize information from a range of cells (e.g., customer feedback).
- Categorize or analyze sentiment (classify emails, group requests, etc.).
For example, you can write =AI("Summarize customer feedback in one sentence", A2:D2) or =AI("Classify this as spam or not spam", B2). You can even add an “AI column” to a table and autofill it with smart suggestions.
This isn’t just for techies—now even the bà cô in accounting can use AI to automate reports, group data, or write quick summaries, all inside the same old Google Sheets. AI is everywhere, not just in fancy new apps. See Google’s official guide.
What’s Next? The Only Way Is Forward
Here’s my challenge: try these tools, experiment, and don’t be afraid to fail. If you have a laptop or even an old PC, set up some open-source tools, play with new AI models, and see what you can build. The more you try, the more you’ll learn. If you’re a BA/PO/PM, you’ll find yourself getting more technical, more curious, and more valuable to your team.
Don’t get replaced by the person who’s already using these tools. The trend is here, ride the wave, don’t get left behind. If you want to share your funniest or worst AI diagrams, or just want to roast some DALL·E output together, send them my way. Let’s keep learning, failing, and building together.
Chúc may mắn!
