Who knew amazon Q Info session would lead me to build Git Analytics?
A late Amazon Q session sparked an idea that grew into Git Analytics — a tool revealing unseen stories in your team’s code.
What if being late to a meeting sparked your next big project?
On October 12, 2025, after our quarterly release, I joined an Amazon Q info session hosted by a colleague.
I was late.
By the time I got in, they were already installing Amazon Q on the CLI and VS Code. I just followed along at first—nothing special.
We built small things:
a snake game
a car game
some unit tests
But one thought kept coming back:
“What if this CLI could automate things… or even plug into CI/CD?”
That question didn’t leave me.
The Idea That Wouldn’t Go Away
The CLI felt natural—like using Git. Fast. Simple. Powerful.
At the end of the session, everyone shared their demos.
Mine didn’t go well—I tried building an end-to-end test but hit authentication issues.
No impressive output.
But I left with something better: curiosity.
That night, I opened one of my repositories and started experimenting.
That’s when Git Analytics was born.
The Mistake That Changed Everything
After hours of prompting, I finally got something working.
Then I broke it.
Worse—I accidentally closed my terminal.
Everything was gone.
No history. No context. No way to reproduce what I just built.
That moment taught me something important:
Treat AI experiments like real software.
So I changed how I worked:
Create a new branch for every idea
Test outputs
Commit working results
Use the goal as the commit message
Then I discovered Amazon Q’s /save and /load.
Now I had:
Git for code
Saved context for AI
That combination changed everything.
Learning to Work With AI
At first, I was very step-by-step:
“Do this.”
“Now do that.”
It worked—but it was slow.
Then I changed one thing:
Instead of telling AI what to do,
I told it what I wanted.
That shift made a huge difference.
Suddenly:
It generated better outputs
I refined instead of micromanaged
It felt like collaboration
AI became the muscle.
I became the direction.
When AI Needs You
As Git Analytics grew, things got messy.
Amazon Q started:
forgetting features
breaking old code
getting confused
That’s when it clicked:
AI doesn’t replace developers—it needs them.
It works best in small chunks.
For bigger systems, it still needs guidance.
My dev experience became essential:
debugging
structuring
steering the direction
Without it, I’d just be following the AI—not leading it.
Why I Built Git Analytics
Simple:
Without metrics, we’re blind.
We can’t improve what we don’t see.
Git already has data—but it’s hard to understand.
So I built something simple:
A multi-repo dashboard
Runs with Docker
No backend setup
Just open and use
Insight without friction.
What the Data Revealed
Once I started using it, the insights were surprising.
👥 Contributors
Not just code volume—but patterns:
who contributes consistently
when activity peaks
how the team moves
🌙 After-Hours Work
Are we overworking?
This shows:
night commits
weekend work
possible burnout signals
🔍 Peer Reviews
Who reviews the most?
Is the workload balanced?
It made collaboration visible.
⚙️ Features vs Bug Fixes
A timeline of:
building vs fixing
innovation vs stability
🧪 Test Coverage
Which changes lack tests?
It’s not about numbers—it’s about accountability.
⏱ Lead Time to Merge
This became my favorite metric.
It shows:
how fast work moves
where bottlenecks are
how smooth the process feels
It’s not just speed—it’s flow.
⚠️ Knowledge Risk
This one is powerful.
If one person owns most of a system:
it’s efficient
but risky
If they leave, the team struggles.
This helps teams:
share ownership
reduce dependency
stay resilient
Key Takeaway
AI tools like Amazon Q are not replacements.
They are multipliers.
They don’t remove the need for skill—
they make skill more powerful.
Git Analytics didn’t come from a plan.
It came from:
curiosity
mistakes
experimentation
And one late meeting.
Final Thought
The future isn’t:
Humans vs AI
It’s:
Humans who know how to use AI