This is a submission for the GitHub Copilot CLI Challenge
What I Built
I built DevDNA — a web app that analyzes a GitHub profile and turns it into a developer personality report.
Instead of just showing stats like repos, commits, and languages, the idea was to answer a more interesting question:
What does your GitHub say about the kind of developer you are?
DevDNA looks at public GitHub data and generates a profile experience that feels more like an intelligence report than a dashboard. It tries to surface patterns like:
- Coding rhythm
- Language dominance
- Activity behavior
- Contribution style
- A “Developer Archetype” (the dramatic centerpiece 😄)
The goal wasn’t to clone GitHub or build another analytics tool. I wanted something that feels:
- personal
- visual
- slightly cinematic
- and very dev-centric
You enter a username, and the system “analyzes” it and reveals a personality-style breakdown.
This project was also a personal experiment in AI-native development — building fast, iterating faster, and treating Copilot CLI as a real collaborator.
Demo
Project link:
👉 DevDNA Demo
Try with usernames like:
- torvalds
- gaearon
- sindresorhus
What happens:
- Landing page with a subtle “digital DNA” background
- Enter a GitHub username
- A short analysis sequence runs
- Then the full DevDNA report appears:
- Identity header (avatar, bio, stats)
- Developer Archetype (main highlight)
- Insight cards
- Language/activity visualizations
My Experience with GitHub Copilot CLI
This project was built with a very intentional mindset:
“What happens if I treat Copilot CLI like a development partner instead of just autocomplete?”
And honestly, that changed everything.
How I used Copilot CLI
I used Copilot CLI throughout the process to:
- Scaffold components quickly
- Structure the result page layout
- Generate API integration logic
- Iterate on UI states and transitions
- Refine animations and interaction flows
- Experiment rapidly without breaking momentum
Instead of switching between docs, StackOverflow, and trial-and-error, I could stay in flow and build continuously.
The most interesting part was using it during the “idea → implementation” phase:
- I could describe what I wanted
- Refine it step by step
- And evolve the product visually and structurally in real time
It felt less like coding line-by-line and more like directing the build.
Where Copilot CLI helped the most
The biggest wins were:
- Rapid prototyping of UI sections
- Structuring complex pages (especially the result screen)
- Iterating on multiple visual ideas quickly
- Handling repetitive setup and wiring
That speed made it possible to focus on the experience:
- How the analysis should feel
- What the reveal moment should look like
- How to present identity instead of just data
Instead of getting stuck in boilerplate.
What surprised me
The biggest shift wasn’t technical — it was mental.
I found myself thinking more about:
- product feel
- user experience
- narrative
- visual identity
And less about:
- syntax
- small implementation details
Copilot CLI helped remove friction, which made experimentation much easier. I could try things, change direction, and push ideas further without the usual overhead.
This project ended up being a mix of:
- curiosity
- fast iteration
- and a lot of “what if I try this next?”
And that’s probably what made it fun to build.
Why I built DevDNA
I’ve always found GitHub profiles interesting, but they mostly show numbers:
- repos
- commits
- followers
- stars
They don’t tell the story.
But if you look at patterns — languages, activity, focus areas — you can start to see the developer behind the code.
DevDNA is basically an attempt to turn:
raw GitHub data → personality signals
Not scientifically accurate.
Not meant to judge.
Just a fun, thoughtful way to look at how people build.
Final Thoughts
This challenge ended up being more than just “build something with Copilot CLI”.
It became an experiment in:
- fast creation
- AI-assisted workflows
- and building something visual and expressive in a short time
I wanted to make something that:
- looks cool
- feels alive
- and makes developers curious to try it on their own profile
If someone runs their username and thinks:
“Okay… that’s actually kind of accurate.”
Then I consider it a success 😄
Top comments (5)
This is inspiring me to build horoscope based on someone's repo lol. Costar but give me your Git handle and lemme tell you your day. Cool project btw ^^^
There might be unexpected behaviour with some features to look into. Maybe median is a better metric since sometimes, we all have that one repo, that has a tone of artifacts.
hmm yeah there can be better metric to look into. we can add a lot of things into this, like user's commit times to know user's most active state and frequency of commit for each hour or something like that...
thanks for suggestions. I'll surely add things into this too.
here is repo if you wanna look more into this -> github.com/user-64bit/dev-dna
I think we'll need to some filters here :) because we need to focus on main used files. will do this too. 😅