DEV Community: Ayush Sharma

[Boost]

Ayush Sharma — Tue, 30 Jun 2026 09:10:08 +0000

GitHub “Finish-Up-A-Thon” Challenge Submission

Ayush Sharma

Jun 5

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

#devchallenge #githubchallenge

4 min read

Stop Typing Your GitHub Password Every Time: Set Up SSH for Git in Linux/WSL

Ayush Sharma — Tue, 30 Jun 2026 09:03:58 +0000

If you're contributing to open source or working with GitHub regularly, you've probably encountered this:

Username for 'https://github.com':
Password for 'https://github.com':

Or worse, GitHub rejects your password because password authentication is no longer supported.

The solution? SSH authentication.

Once configured, you can push, pull, and clone repositories without entering your credentials every time.

In this guide, I'll show you how to configure SSH for Git on Linux or WSL.

Why use SSH?

Instead of authenticating with your username and Personal Access Token (PAT) for every repository, SSH uses a pair of cryptographic keys:

Private Key → Stays on your computer.
Public Key → Added to your GitHub account.

When GitHub sees your private key, it verifies your identity automatically.

No passwords.
No tokens.
Just Git.

Prerequisites

Linux (Ubuntu, Debian, Fedora, etc.) or WSL2
Git installed
A GitHub account

Step 1 - Verify SSH is installed

Open your terminal and run:

ssh -V

Example output:

OpenSSH_9.6p1 Ubuntu-3ubuntu13.12, OpenSSL 3.0.13

If you see a version number, you're good to go.

Step 2 - Generate a new SSH key

GitHub recommends using the modern Ed25519 algorithm.

Run:

ssh-keygen -t ed25519 -C "your-email@example.com"

Replace the email with the one associated with your GitHub account.

Example:

ssh-keygen -t ed25519 -C "ayush@example.com"

You'll be asked:

Enter file in which to save the key

Simply press Enter to accept the default location:

~/.ssh/id_ed25519

Step 3 - Choose a passphrase

Next you'll see:

Enter passphrase (empty for no passphrase):

You have two options:

Option 1 (Recommended for personal machines)

Press Enter twice.

This creates the key without a passphrase, making Git authentication seamless.

Option 2 (Recommended for shared or highly secure machines)

Enter a strong passphrase.

This adds an extra layer of security but requires unlocking the key before use.

Step 4 - Start the SSH agent

Run:

eval "$(ssh-agent -s)"

Example output:

Agent pid 12345

The SSH agent securely manages your private keys.

Step 5 - Add your private key

Run:

ssh-add ~/.ssh/id_ed25519

Expected output:

Identity added: /home/user/.ssh/id_ed25519

Step 6 - Copy your public key

Display the public key:

cat ~/.ssh/id_ed25519.pub

You'll see something similar to:

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI........ your-email@example.com

Copy the entire line.

Step 7 - Add the key to GitHub

Navigate to:

-> GitHub → Settings → SSH and GPG keys → New SSH key

Give it a meaningful title, for example:

-> Ubuntu WSL - Work Laptop

Paste the copied public key into the Key field.

Click Add SSH key.

Done!

Step 8 - Test the connection

Run:

ssh -T git@github.com

The first time you'll be asked:

The authenticity of host 'github.com' can't be established.
Are you sure you want to continue connecting (yes/no)?

Type:

yes

If everything is configured correctly, you'll see:

Hi your-username! You've successfully authenticated, but GitHub does not provide shell access.

Congratulations! SSH is now configured successfully.

Step 9 - Update existing repositories

If your repositories currently use HTTPS:

https://github.com/username/project.git

Switch them to SSH:

git remote set-url origin git@github.com:username/project.git

Verify:

git remote -v

Expected:

origin  git@github.com:username/project.git (fetch)
origin  git@github.com:username/project.git (push)

Verify your Git identity

You can also verify your Git configuration:

git config --global --list

Or check specific values:

git config --global user.name
git config --global user.email

If needed, configure them:

git config --global user.name "Your Name"
git config --global user.email "your-email@example.com"

Troubleshooting

Permission denied (publickey)

Ensure your key is loaded:

ssh-add ~/.ssh/id_ed25519
~/.ssh doesn't exist

Generate a new SSH key using the steps above.

The directory will be created automatically.

Git still asks for a username/password

Your repository is likely still using HTTPS.

Check:

git remote -v

If it shows:

https://github.com/...

Switch it to SSH:

git remote set-url origin git@github.com:username/repository.git

Final Thoughts

Setting up SSH takes less than 10 minutes, but it saves countless authentication prompts throughout your development journey.

If you're contributing to open source, working across multiple repositories, or simply want a smoother Git workflow, SSH is well worth the one-time setup.

Happy coding!

Drop a ❤️ if you find it helpful.

Exploring HackerRank's Open-Source AI Hiring Agent: A Hands-on Walkthrough (Guide)

Ayush Sharma — Thu, 25 Jun 2026 16:33:33 +0000

Can an AI evaluate a resume the way a recruiter would?

That question made me explore HackerRank's open-source Hiring Agent (thanks to Hardik Goyal). I wanted to understand how it works, how difficult it is to set up, and what kind of feedback it actually provides. This article is a walkthrough of that journey-from setting it up on WSL Ubuntu to debugging a few unexpected issues and finally running my resume through the evaluation pipeline.

Why I Tried This

A few days ago, while discussing resume reviews with one of my seniors, Hardik Goyal, I asked him if there was a good way to get an estimate of how an AI-based hiring system might evaluate my resume.

His response was simple:

"I think HackerRank recently open-sourced their ATS, try that."

That got me curious enough to try it myself.

After looking into the repository, I realized it wasn't actually a complete ATS, but an open-source AI resume evaluation pipeline published by HackerRank's InterviewStreet GitHub organization.

Since I was already planning to improve my resume, I thought this would be a good opportunity to understand how the project works, set it up locally, and see what kind of insights it could provide.

This article is a walkthrough of that entire experience-from the initial setup to debugging a few unexpected issues, and finally running the evaluation successfully.

What This Project Is (and Isn't)

Before jumping into the setup, it's worth clarifying one thing.

This project isn't the complete hiring system used by HackerRank, nor should its score be treated as an industry-standard ATS score.

Instead, it's an open-source project that demonstrates one part of a hiring workflow—AI-assisted resume evaluation.

It combines resume parsing, GitHub analysis, and LLM-based reasoning to produce a structured report instead of simply matching keywords. src

That transparency is what caught my attention.

Overall Architecture

The entire pipeline is surprisingly straightforward.

Instead of only reading the PDF, it also tries to understand your GitHub profile before evaluating your overall engineering profile.

My Setup

I used the following environment:

Windows 11
WSL2 (Ubuntu)
Nano (for quick terminal edits)
Python 3.12
Google Gemini API (AI Studio)
GitHub API (pre-configured)

The setup itself wasn't difficult, but I did run into a few issues along the way.

Cloning the Repository

The first step was simply cloning the project.

git clone https://github.com/interviewstreet/hiring-agent.git
cd hiring-agent

After that I created a Python virtual environment.

Or at least... I tried to.

Issue #1 — Python Wasn't Found

My first attempt was:

python -m venv .venv

which immediately failed with:

Command 'python' not found

Nothing serious.

Ubuntu ships with python3 instead of python.

So I switched to:

python3 -m venv .venv

I thought that would solve it.

It didn't.

Issue #2 — Missing venv Package

The next error looked like this:

It turns out Ubuntu doesn't install the virtual environment package by default.

Installing it solved the problem.

sudo apt update

sudo apt install python3.12-venv

After that:

python3 -m venv .venv

source .venv/bin/activate

worked perfectly.

Installing Dependencies

Once the virtual environment was ready, installing everything else was straightforward.

pip install -r requirements.txt

The repository installs everything required for:

PDF parsing
Gemini
Ollama
GitHub integration
Jinja templates
Pydantic models

No surprises here.

Configuring Gemini

The project supports two providers:

Ollama
Google Gemini

Since I already had a Gemini API key, I decided to use that.

While editing the .env file, I also ended up learning two Nano shortcuts that I'll probably keep using:

-> Alt + U → Undo
-> Alt + E → Redo

The .env file looked like this:

LLM_PROVIDER=gemini
DEFAULT_MODEL=gemini-2.5-pro
GEMINI_API_KEY=YOUR_API_KEY

Simple enough.

Or so I thought.

Organizing Resume Files

Instead of keeping resumes scattered across different folders, I created a dedicated directory inside the project.

(mkdir resumes)

Since my resume was stored on my Windows W: drive, I first verified it was available inside WSL using ls /mnt, then copied it into a dedicated resumes folder while giving it a shorter filename for easier execution.

ls /mnt

cp "/mnt/w/ResumeS/<PATH_TO_MY_RESUME>/Ayush_Sharma_Resume.pdf" \
resumes/resume_NEW_NAME.pdf

hiring-agent
│
├── resumes
│     ├── resume_general.pdf
│     ├── resume_google.pdf
│     └── resume_microsoft.pdf

This makes it easy to evaluate different resume versions without changing commands every time.

First Run

With everything configured, I finally ran:

python score.py resumes/resume_microsoft.pdf

The logs started scrolling.

The Gemini provider initialized successfully.

Everything looked good...

Until it suddenly stopped.

At this point, I wasn't sure whether the problem was with my API key, my project configuration, or the repository itself.

Issue #3 — Gemini Quota Error

The error looked something like this:

429

Quota exceeded

limit: 0

At first, I assumed I had entered the wrong API key.

Then I checked Google AI Studio.

Everything looked normal.

I even verified that the project existed.

Still the same error.

Debugging the API

Instead of guessing, I decided to verify each assumption one by one.

The first thing I checked was whether my API key actually worked.

I listed all available Gemini models using a simple curl request.

It worked.

Next, I tested a small prompt directly against the API.

Again, it worked.

That confirmed:

my API key was valid
the Gemini API was working
networking wasn't the problem

The issue had to be somewhere else.

The Actual Fix

After comparing the responses, I noticed something interesting.

The repository was configured to use:

gemini-2.5-pro

But my direct API request used:

gemini-2.5-flash

Changing one line inside .env fixed everything.

DEFAULT_MODEL=gemini-2.5-flash

The project started working immediately.

Sometimes debugging is simply about eliminating possibilities one by one instead of assuming the first error message tells the whole story.

GitHub Enrichment

One feature I genuinely liked was the GitHub integration.

Instead of relying only on the resume PDF, the project also looks at your GitHub profile.

It fetches repositories, classifies them, and then asks the LLM to identify the projects that best represent your work before generating the evaluation.

That adds another layer of context which many simple resume checkers completely ignore.

No doubt, this was actually my favorite feature of the project.

How the Evaluation Works

Once everything is collected, the evaluation pipeline looks like this.

The final report isn't just a number.

It also explains why certain scores were assigned.

What I Liked

I wasn't particularly interested in chasing a higher score.

I was more interested in understanding the evaluation process.

One thing I really appreciated was the idea of bonus points.

Instead of only looking for missing things, the system also rewards additional effort, such as maintaining a portfolio website or having a LinkedIn profile.

I also liked that deductions weren't hidden.

Rather than silently reducing the score, the report explicitly mentions why points were deducted.

Whether you agree with those deductions or not, at least you know what influenced the result.

The recommendations section was another pleasant surprise.

They weren't just generic resume advice copied from the internet.

They were generated based on the overall profile the system had built using both the resume and GitHub.

Not every suggestion perfectly matched my situation, but several of them were genuinely useful and worth thinking about.

That kind of transparency makes the feedback much more actionable.

For reference, this is the report generated for my resume:

Things That Could Be Better

Like any open-source project, there is room for improvement.

I think project ranking could become smarter by considering more GitHub signals instead of relying primarily on LLM selection.

It would also be nice if the system automatically detected deployed applications from platforms like GitHub Pages, Vercel, Netlify, or Render instead of assuming every project without an explicit demo deserves a deduction.

Another improvement could be different evaluation rubrics for different roles.

The expectations for a backend engineer, machine learning engineer, or frontend developer are obviously different, so role-specific scoring could make the evaluation even more meaningful.

What I Learned

I originally started this just to test a resume.

Instead, I ended up learning much more than I expected.

Along the way I got to:

configure Python environments inside WSL
debug missing Ubuntu packages
work with the Gemini API
investigate API quota issues
understand GitHub rate limits
explore how LLMs can be used for structured information extraction
see how AI-assisted resume evaluation pipelines are designed

Sometimes the setup process teaches you just as much as the project itself.

Final Thoughts

I don't think anyone should treat the final score from this project as an absolute measure of their resume.

Hiring decisions involve far more context than any single AI system can capture.

But I do think it's a great project to explore if you're curious about how AI-assisted resume evaluation works behind the scenes.

It offers a transparent look into how an AI-powered resume evaluation pipeline can be built, and I appreciate that it explains its reasoning instead of hiding everything behind a single percentage.

If you're interested in AI tooling, resume evaluation, or simply want to understand how these systems work under the hood, it's definitely worth exploring.

And if you're into open source, it also looks like a fun project to contribute to.

Resources

GitHub Repository: https://github.com/interviewstreet/hiring-agent/
Google AI Studio: https://aistudio.google.com/?utm=ayushHardeniya

If you've tried this project—or know of similar open-source tools—I'd love to hear your experience in the comments.

If you enjoyed the article, consider leaving a ❤️. It really helps!

Planning to deploy this project! Any tips are most welcome to make it scalable ?

Ayush Sharma — Sat, 13 Jun 2026 10:56:20 +0000

GitHub “Finish-Up-A-Thon” Challenge Submission

Ayush Sharma

Jun 5

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

#devchallenge #githubchallenge

4 min read

[Boost]

Ayush Sharma — Wed, 10 Jun 2026 15:09:55 +0000

GitHub “Finish-Up-A-Thon” Challenge Submission

Ayush Sharma

Jun 5

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

#devchallenge #githubchallenge

4 min read

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

Ayush Sharma — Fri, 05 Jun 2026 14:18:24 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

Jal-Drishti Delhi is an urban flooding and hydrology command center designed to explore how municipal authorities can monitor flood-prone areas, assess preparedness, and respond to flooding events across Delhi.

The project was originally built for the Urban Flooding & Hydrology Engine challenge during India Innovates 2026. It already included flood monitoring, hotspot analysis, drainage monitoring, readiness scoring, historical analytics, emergency workflows, and GIS visualization.

While the project was functional, a few planned capabilities never made it into the original version because of time constraints. When I came across the GitHub Finish-Up-A-Thon, I decided to revisit the project and complete those missing pieces rather than starting something new.

Project: Jal-Drishti Delhi
Tech Stack: React, Flask, Leaflet, Recharts
Repository: https://github.com/ayushHardeniya/Jal-Drishti-Delhi
Live Demo: https://jal-drishti-delhi-mu.vercel.app
Architecture Documentation: https://github.com/ayushHardeniya/Jal-Drishti-Delhi/blob/main/ARCHITECTURE.md

Demo

Walkthrough Video

Dashboard Before Finish-Up-A-Thon

Dashboard After Finish-Up-A-Thon

The Comeback Story

The original version already provided:

Flood hotspot monitoring
GIS visualization
Drainage network analysis
Historical flood analytics
Pre-Monsoon Readiness Scoring
Emergency response workflows

However, several parts of the original roadmap were still missing.

Before Finish-Up-A-Thon	After Finish-Up-A-Thon
Flood monitoring	Flood monitoring
Drainage analysis	Drainage analysis
Historical analytics	Historical analytics
Readiness scoring	Readiness scoring
Emergency workflows	Emergency workflows
No resource allocation recommendations	Resource Allocation Engine
No scenario planning capabilities	Flood Scenario Simulator
No centralized reporting workflow	Reports & Exports Center
No deployment recommendations	Prioritized resource recommendations
No comparative simulations	Baseline vs scenario comparison

Rather than redesigning the application, I focused on completing the operational layer that sits between monitoring and action.

1. Resource Allocation Engine

The first major addition was a Planning module.

This feature evaluates flood risk, readiness scores, drainage conditions, and available resources to generate prioritized deployment recommendations.

Each recommendation includes reasoning and estimated impact so that users can understand why a location is being prioritized.

2. Flood Scenario Simulator

The second addition was a Scenario Simulator.

This module allows users to run what-if analyses by changing rainfall intensity and operational conditions. The simulator compares baseline conditions with projected outcomes and highlights the resulting impact on risk, readiness, and response requirements.

3. Reports & Exports Center

The third addition was a Reports & Exports Center.

This brings together operational reporting, planning outputs, scenario reports, and data exports into a single workflow. The goal was to make it easier to generate and share information from within the application instead of relying on multiple pages.

Architecture Approach

One design decision I intentionally kept throughout this work was preserving the existing architecture.

The application remains a Flask + React project with no additional backend services, databases, or major structural changes.

The new functionality was integrated into the existing codebase by extending the current services, APIs, and frontend modules rather than rebuilding them.

This helped keep the project consistent while still adding meaningful capabilities.

A simplified view of the application structure is shown below.

System Overview

React Frontend
│
├─ Dashboard
├─ Hotspots
├─ Drainage
├─ Planning
├─ Scenario Simulator
├─ Reports & Exports
├─ Readiness
└─ Emergency Actions
        │
        ▼
Flask REST API
│
├─ app.py
├─ services.py
└─ data.py
        │
        ▼
Flood Risk Analysis
Readiness Scoring
Resource Allocation
Scenario Simulation
Reporting

Development Evidence

One thing I liked about this challenge was that it encouraged finishing something that already existed.

Instead of starting a new repository, I was able to revisit a project that had been sitting unfinished and complete the parts that were originally postponed.

The implementation work completed during the challenge can be viewed in the merged pull request:

Finish-Up-A-Thon Pull Request

add planning, scenario simulation nd reporting capabilities to Jal-Drishti Delhi #1

ayushHardeniya posted on Jun 05, 2026

contains the work completed while revisiting Jal-Drishti Delhi as part of the GitHub Finish-Up-A-Thon by dev community

the project originally focused on flood monitoring, analytics, readiness scoring, and emergency operations. a few planned capabilities were still missing:

Limitations before Finish-Up-A-Thon

No resource allocation recommendations
No scenario planning module
No multi-day forecast timeline
No downloadable PDF situation reports
No operational deployment recommendations
No comparative flood scenario analysis

these were part of the longer-term roadmap but were left for future development due to tiime constraints during the initial build

the goal of this update was to complete some of the planning and reporting capabilities that were left out in the original version (e.g.)

Original Modules
├─ Dashboard
├─ Hotspots
├─ Drainage
├─ Analytics
├─ Historical
├─ Readiness
└─ Emergency

New Modules
├─ Planning
├─ Scenario Simulator
└─ Reports & Exports

Added (with this PR)

Resource Allocation Engine
- prioritized deployment recommendations
- resource inventory overview
- impact estimates and reasoning for recommendations

Flood Scenario Simulator
- What-if scenario analysis
- baseline vs simulated comparisons
- response planning support

Reports & Exports Center
- centralized access to reports
- operational exports and downloads
- Consolidated reporting workflow

Other updates

Updated navigation nd page structure
Added project branding assets and favicon
Refreshed README and ARCHITECTURE documentation
Minor UI polish and consistency improvements
Added screenshots for project state before and after this finish-up-a-thon

Note: the overall architecture remains unchanged... the new functionality was integrated into the existing Flask + React application without introoducing additional backend services or major architectural changes

View on GitHub

This pull request contains the complete set of changes implemented during the Finish-Up-A-Thon, including the Planning module, Scenario Simulator, Reports & Exports Center, documentation updates, and project assets.

Commit History

GitHub commit history:
https://github.com/ayushHardeniya/Jal-Drishti-Delhi/commits/main/

Deployment History

The repository also contains additional screenshots documenting the project's state before and after the Finish-Up-A-Thon updates, available in the screenshots directory.

My Experience with GitHub Copilot

I used GitHub Copilot throughout this completion process.

Since this was an existing project, the most useful part was not generating entire features automatically but helping me move through an established codebase faster.

I used Copilot to explore implementation paths, understand existing patterns, and speed up repetitive work while keeping the overall architecture consistent.

For larger additions such as the Resource Allocation Engine, Scenario Simulator, and Reports Center, it was particularly useful for navigating the repository and reducing the amount of boilerplate involved in extending the existing system.

The final implementation still required architectural decisions, validation, testing, and integration work, but Copilot helped reduce the friction of revisiting and expanding an older project.

How Do You See Yourself? A Coder or An Engineer.

Ayush Sharma — Sun, 08 Jun 2025 05:49:38 +0000

Sometimes, it becomes necessary to reflect on ourselves and consider our perspective.
Isn't it, Answer my question if you agree, And Lemme also know what you reflect for yourself...

DEV Community: Ayush Sharma

[Boost]

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

Stop Typing Your GitHub Password Every Time: Set Up SSH for Git in Linux/WSL

Why use SSH?

Prerequisites

Step 1 - Verify SSH is installed

Step 2 - Generate a new SSH key

Step 3 - Choose a passphrase

Option 1 (Recommended for personal machines)

Option 2 (Recommended for shared or highly secure machines)

Step 4 - Start the SSH agent

Step 5 - Add your private key

Step 6 - Copy your public key

Step 7 - Add the key to GitHub

Step 8 - Test the connection

Step 9 - Update existing repositories

Verify your Git identity

Final Thoughts

Exploring HackerRank's Open-Source AI Hiring Agent: A Hands-on Walkthrough (Guide)

Why I Tried This

What This Project Is (and Isn't)

Overall Architecture

My Setup

Cloning the Repository

Issue #1 — Python Wasn't Found

Issue #2 — Missing venv Package

Installing Dependencies

Configuring Gemini

Organizing Resume Files

First Run

Issue #3 — Gemini Quota Error

Debugging the API

The Actual Fix

GitHub Enrichment

How the Evaluation Works

What I Liked

That kind of transparency makes the feedback much more actionable.

Things That Could Be Better

What I Learned

Final Thoughts

Resources

Planning to deploy this project! Any tips are most welcome to make it scalable ?

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

[Boost]

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

From Monitoring Dashboard to Decision Support Platform: Finishing Jal-Drishti Delhi

What I Built

Demo

Walkthrough Video

Dashboard Before Finish-Up-A-Thon

Dashboard After Finish-Up-A-Thon

The Comeback Story

1. Resource Allocation Engine

2. Flood Scenario Simulator

3. Reports & Exports Center

Architecture Approach

System Overview

Development Evidence

add planning, scenario simulation nd reporting capabilities to Jal-Drishti Delhi #1

Limitations before Finish-Up-A-Thon

Added (with this PR)

Other updates

Commit History

Deployment History

My Experience with GitHub Copilot

Links

How Do You See Yourself? A Coder or An Engineer.