DEV Community

Ayush Ranjan
Ayush Ranjan

Posted on

First5: I built an CLI so my senior engineer stops losing context and finally review my PRs 💀

#devchallenge #hf26challenge

I built first5. It's a dead-simple terminal tool powered by local open models via Ollama. It does only the boring first 5 minutes of any task, sets up your imports, types, and files, and opens your editor with your cursor sitting on line 1 so you can just start typing.

I actually made this because of two real problems I see every single day at work:

1. The psychological "dread" tasks

You know those tasks where you sit there staring at an empty file for 45 minutes doing literally anything else? Writing an OpenAPI validator, writing test harness boilerplate, setting up a migration doc. The task itself isn't even that hard, but in your brain you make it this massive mountain. You dread just figuring out where the file goes, importing 8 packages, writing the interfaces, and setting up the classes. Because activation energy is so high, the ticket sits in your sprint for 4 days.

first5 destroys that dread. You don't ask it to write your whole feature (which usually just gives you 300 lines of weird hallucinated code you have to spend an hour debugging anyway). It just does the annoying first 5 minutes: scans your actual repo, imports the packages, writes the interface, and stops right at the first business logic line.

2. My senior engineer who gets pulled into 50 meetings

My senior engineer is great, but he gets pulled into random Slack threads, incident huddles, and prod discussions every 20 minutes. He will start a task, get pinged on Slack, disappear for 2 hours, and then come back to an empty terminal having zero clue where he left off.

When you run first5 with zero arguments, it acts as an Active Radar. It looks at his uncommitted git changes, his assigned Jira/Linear tickets, and Postman API collections, and lists them right in the terminal with arrow keys. He hits enter on one, and his branch is made, file is scaffolded, and VS Code opens right to where he needs to write code.

And honestly? The real reason I built this is so he can finally finish his own backlog and review my open PRs.

Demo

Here is a quick walkthrough of running first5 on our real backend codebase (backend-v3):

Watch the Demo Video Here

What happens in the video:

  1. I run first5 in terminal it shows the radar with arrow keys of where work was left off.
  2. I give it a real task: 
   first5 "create script to validate domain yaml files against openapi schema"
Enter fullscreen mode Exit fullscreen mode
  1. In under 2 seconds, it scans our repo, detects TypeScript, Jest, and Express, and creates src/validators/domainYamlValidator.ts.
  2. It literally found our actual repo's docs/openapi.json, imported js-yaml and ajv, built the TypeScript interface, and opened VS Code with the cursor waiting at line 26.
  3. I write one line of code, run first5 done, and it stages and commits the work with a clean conventional commit.

Code

The entire codebase is MIT licensed, lightweight, and open source:

GitHub logo ayuuuuu0-0 / first5

first5

Scaffolds the first 5 minutes of any dev task, places your cursor on line 1, and opens your editor.

The Idea

Most developers don't struggle with coding. They struggle with starting:

  • You get pulled into Slack or a standup and come back with zero context.
  • You dread copy-pasting acceptance criteria from Jira or Linear.
  • You waste 10 minutes setting up imports, mocks, and file paths.

Most AI coding tools try to write the entire feature for you, spitting out 300 lines of code you don't trust and have to audit.

first5 does the opposite. It only does the boring first 5 minutes:

  1. Pulls context from your active git branch or ticket (Jira / Linear / GitHub / Slack).
  2. Scans your repo's tech stack (TypeScript, React, Python, Go, Rust).
  3. Generates the boilerplate, imports, and types.
  4. Leaves a half-finished comment or assertion right where logic begins.
  5. Spawns your editor (code…


View on GitHub


Repo: https://github.com/ayuuuuu0-0/first5

How I Built It

I didn't want any bloated frameworks or slow heavy dependencies. It's written in native Node.js ESM.

  • The Brain (Local Open-Source AI): It runs on Ollama running locally. On my laptop, I used qwen2.5-coder:14b (and tested with 7b). It outputs pure structured JSON directly with zero network calls.
  • The Context Scanner (src/context.js): Before it talks to the model, it inspects process.cwd(): reads dependencies in package.json, checks active git branch, recent modified files, and directory tree. That's why when I asked for an OpenAPI validator, it actually knew our schema was located at docs/openapi.json without me telling it!
  • The Hemingway Hook: Ernest Hemingway used to stop writing mid-sentence so he always knew where to start the next morning. first5 prompts the model to write the scaffolding and stop right at the first check, leaving a prompt comment and cursor line number.
  • The Editor Launcher (src/editor.js): Automatically spawns your editor (code -g file:line, cursor, or nvim) directly focused on the target line.
  • The Radar (src/radar.js): When you run first5 with no arguments, it inspects your git diff, assigned tickets (Jira / Linear), and Postman requests, and lets you pick with arrow keys using raw terminal input.
  • Closing the Loop (first5 done): Once you're done, running first5 done reads your active branch and ticket name, stages your changes, and runs git commit with a clean message.

Why Does Open Innovation Matter?

This whole project only makes sense because of open-weight models.

If you work at any company, you cannot just take your entire company's private repository tree, uncommitted git diffs, internal Jira tickets, and proprietary routes and blast them over the internet to a closed cloud API. Security and legal will immediately shut that down.

Because models like qwen2.5-coder and llama3.2 are open weights, I can run them on my own laptop via Ollama with 100% offline privacy. My company's codebase never touches an external server, and it runs in 1.5 seconds on Apple Silicon without paying API bills. Open innovation is the only reason tools like this can actually be used on real production codebases.

The Lazy Payoff

This week alone, writing the boilerplate for YAML validation, setting up route mocks, and creating test files usually eats 15 to 20 minutes of wandering around between Slack, Jira, and file trees before typing actual logic.

first5 drops that activation time from 20 minutes of dread down to literally 3 seconds. You hit enter, your editor opens with the imports already resolved, and you just finish the line. It turns the hardest part of work (getting started) into a non-issue.

And best of all, my PRs might finally get reviewed today.

Prize Categories

  • Primary: Hacktoberfest Open-Source AI Challenge Week 3 ("Slow and Steady" / Developer Laziness)
  • Open-Source AI / Local Models: Best use of Ollama & Open-Weight Models for Developer Tooling

Top comments (0)