DEV Community: Arth

[Boost]

Arth — Sat, 07 Feb 2026 16:54:51 +0000

I Built DevDNA — A Tool That Turns GitHub Profiles Into Developer Personality Reports (Using Copilot CLI)

Arth ・ Feb 7

#devchallenge #githubchallenge #cli #githubcopilot

I Built DevDNA — A Tool That Turns GitHub Profiles Into Developer Personality Reports (Using Copilot CLI)

Arth — Sat, 07 Feb 2026 16:54:27 +0000

This is a submission for the GitHub Copilot CLI Challenge

Github Repo
Live

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 😄

Sliding Window Technique

Arth — Tue, 10 May 2022 18:24:24 +0000

Introduction

The sliding window technique is used for reducing some redundant calculations that slow down the program. like it can reduce time complexity from O(n^2) to O(n) with O(1) space complexity.

Why use it?

First of all it reduce time coplexity and also with O(1) space complexity. so let's understand with Example..
So we want to find maximum sum of k consecutive integer from array, so brute force would look like this for k=5,

#include<iostream>
#include<vector>
using namespace std;
int main(){
    vector<int> arr = {5,2,6,7,7,3,2,1,3,9};
    int final_max = 0;
    for(int i=0;i<arr.size()-5;i++){
        int temp_max = 0;
        for(int j=i;j<i+5;j++){
            temp_max += arr[j];
        }
        if(temp_max>final_max){
            final_max = temp_max;
        }
    }
    cout << final_max << endl;
    return 0;
}

But time complexity of the above program is O(nk)

Brute Force Approach

As per we can see in the above image brute approach checks every pattern of k length(here k=5). if you compare the above code with this image you will understand it.

here k=5 so it won't make too much difference in O(n) and O(nk) but what if k is too big. then it will impact the running time of the program, so what to do now? can we implement the above code to O(n)?

The answer is YES!! , with the use of the sliding window, we can reduce the time complexity of the above code O(n).

How does Sliding Window Works?

So let's see how sliding window works.
let me give you simple visual with small array,

{5,2,6,7,7,3,2,1,3,9}
for k=3 (because k=5 is too much to write)
{5,2,6} --> first 3 elements
{2,6,7} --> remove 5 and add 7 
{6,7,7} --> remove 2 and add 7
{7,7,3} --> remove 6 and add 3
{7,3,2} --> remove 7 and add 2
{3,2,1} --> remove 7 and add 1
{2,1,3} --> remove 3 and add 3
{1,3,9} --> remove 2 and add 9

let's understand with second example,

 {5, 7, 1, 4, 3, 6, 2, 9, 2}
 k=5
 {5,7,1,4,3} --> first 5
 {7,1,4,3,6} --> remove 5 and add 6
 and so on.

As we can see in the above image it moves one step at one time. so this is how actually it works.

Let's Code

Code for a maximum sum of k consecutive integer from the array, using the sliding window technique.

#include<iostream>
#include<vector>
using namespace std;
int sum_of_k_ele(vector<int> arr,int k){
    int sum = 0;
    for(int i=0;i<k;i++){
        sum += arr[i];
    }
    return sum;
}
int main(){
    vector<int> arr = {5,2,6,7,7,3,2,1,3,9};
    int k=3;
    // below function will be used only once 
    // for finding sum of first k digits
    int final_sum = sum_of_k_ele(arr,k);

    int temp_sum = final_sum;
    for (int i=k;i<arr.size();i++){
        temp_sum = temp_sum - arr[i-k];
        temp_sum = temp_sum + arr[i];
        if(temp_sum>final_sum){
            final_sum = temp_sum;
        } 
    }
    cout << final_sum << endl;

    return 0;
}

When to use?

When you are looking for a subrange in a given string or array-like highest or smallest value or targeted value.
it involves data structure which is iterable like string or array.
when there can be brute force solution with O(n^2) or (2^n)

More Examples...

Find all anagrams in a string --> Solution
Permutation in string --> Solution

Note : Solutions in above questions are just plain code.

## References

Thank You 😊😊

Pascal's Triangle

Arth — Mon, 09 May 2022 17:54:43 +0000

Introduction

In mathematics, Pascal's triangle is triangular array of binomial coefficient.
below you can see how it looks like..

How to Build it?

First of all start with "1" and second rows as "1 1" then we can clearly see every element in next rows(except 1) if sum of two elements from above row. (i.e, 1+1=2, 1+2=3, 1+3=4) and with this rules we can create pascal's triangle of n rows.
Below is visual of how it will look like,

Formula

[ ] let's take 0th row as first row and 0th column as first column, so we can get each value using formula where n is row number and k is column number. so for finding 1st(0 indexed) element in 2nd row we can write 2C1 which will give 2.
[ ] There is one another technique, in which we need to solve (x + y)^n for nth row, if we solve (x +y)² then we will get 2nd row as coefficient of x and y in this solved formula which is x² + 2xy + y² . coefficients are (1 ,2 , 1) which is second row in pascal's triangle.

Implementation

So it is time to code let's see how we can implement it which some different approaches.
Approach 1 : nCr formula

#include<iostream>
using namespace std;

// return Factorial of val
int fact(int val){
    int ans = 1;
    for(int i=1;i<=val;i++){
        ans = ans* i;
    }
    return ans;
}
// return next value in pascal triangle
int nextval(int row, int col){
    int result;
    result = fact(row) / (fact(col)* fact(row-col));
    return result;
}
int main(){
    int n = 5; // creating pascal's triangle of 5 rows
    for (int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            cout << nextval(i,j) << " ";
        }
        cout << endl;
    }
    return 0;
}

Approach 2: Another Formula

#include<iostream>
using namespace std;
int main(){
    int rows = 5;

    for (int i=1;i<=rows;i++){
        int nCr = 1;
        cout << 1 << " ";
        for(int j=1;j<i;j++){
            nCr = nCr *(i-j)/j;
            cout << nCr << " ";
        }
        cout << endl;
    }
    return 0;
}

Approach 3: Using Vector for storing sum of two elements of previous row,

#include<iostream>
#include<vector>
using namespace std;
vector<vector<int>> pascal_triangle(int numRows) {
    vector<vector<int>> result(numRows);
    for(int i=0;i<numRows;i++){
        result[i].resize(i+1);
        result[i][0]=result[i][i]=1;

        for(int j=1;j<i;j++){
            result[i][j] = result[i-1][j] + result[i-1][j-1];
        }
    }
    return result;
}
void print(vector<vector<int>> result){
    for(int i=0;i<result.size();i++){
        for(int j=0;j<result[i].size();j++){
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}
int main(){
    int n=10;
    vector<vector<int>> result = pascal_triangle(n);
    print(result);
    return 0;
}

Approach 4 : Python3
when we concatenate [1] and [0] like [1] + [0] and [0] + [1] then we get [1,0] and [0,1] , now sum of every element of list1 and list2 will be [1,1] which if second row of pascal triangle now this same process with [1,1] then we'll get [1,1,0] and [0,1,1] then [1,2,1] , after repeating this process we can get pascal's triangle of n rows.

def pascal_triangle(numRows):
    ans = [[1]]
    for _ in range(1,numRows):
        a = ans[-1] + [0]
        b = [0] + ans[-1]
        sum_ab = [x+y for (x,y) in zip(a,b)]
        ans.append(sum_ab)
    # print(ans)
    return ans

result = pascal_triangle(5)
for i in result:
    print(i)

There are still other implementation of pascal's triangle , if you know any then let me know in comment box.

Some amazing facts

[ ] if you have noticed if we sum of element in row then we'll get 2^n , where n is row number in that pascal's triangle. ( 1 = 2° , 1+1 = 2 , 1+2+1 = 2² )
[ ] if we take whole row as one number then it is power of 11, ( 11° = 1, 11 = 1 1, 11² = 1 2 1 )
[ ] Also there are some other patterns in pascal's triangle which you can see in below image,

References

Thank You 😊😊

Digital Root

Arth — Fri, 18 Mar 2022 16:54:09 +0000

i found this while attempting CP Question and i got curious about it then i thought i should share this topic to everyone so here it is...

What is Digital root? if you have done little competitive programming or practice for Data Structure or anything else you have got problem where you need to sum all digits of number and doing this process until number became single digit number. so that is Digital Root , let's talk about it.

Example:
123 = 1+2+3 => 6
456 = 4+5+6 => 15 = 1+5 => 6

There are Few solution which can solve this Problem like Brute Force, but that will slow so we'll try mathematical technique to solve it which is digital root.

Before solving this problem ,let me tell you some interesting properties of Number 9:

when you multiply any number(>0) with 9 then sum of all digits of that number will always 9 . Example : 345*9 = 3105 => 3+1+0+5 => 9 , you can check yourself this condition (try different numbers)
When we add 9 to any number(here add means concatenating ) sum of all digits won't get effected, Example : 345 => 3+4+5 => 12 => 1+2 => 3, now add 9 , 3459 => 21 => 2+1=>3
when we divide any number by 9 , then what remainder we get is same as digital root of that number. Example : 15/9 => 6 and 15=> 1+5=>6
Any Perfect Square's digital root will be 1,4,7,9 (16=>1+6=>7, 36=>3+6=>9 etc)

First i suggest to check out this Leetcode Question

So for n==0 digital_root = 0
otherwise digital_root = 1 + ((n-1)%9)
Let's code this
C++

#include <iostream>
using namespace std;
int digital_root(int n){
    if (n==0)return 0;
    else{
        return 1 + ((n-1)%9);
    }
}
int main() {
    int n;
    cout << "Enter Number: ";
    cin >> n;
    cout <<endl;
    cout << "Digital Root Value :"  << digital_root(n);
    return 0;
}

Python3

def digital_root(n):
    if n==0:
        return 0
    else:
        return 1 + ((n-1)%9)

n = int(input("Enter Number: "))
print("Digital Root :",digital_root(n))

If you want to Know more about it then check Digital_Root

Open for Suggestion
Thank You