DEV Community: Muhammad Hamid Raza

AgentJr — The AI Junior Developer That Manages Your Entire Freelance Business While You Sleep

Muhammad Hamid Raza — Sun, 28 Jun 2026 15:28:30 +0000

AgentJr — The AI Junior Developer That Manages Your Entire Freelance Business While You Sleep

Most "AI developer tools" do one thing: write code.

AgentJr does everything a real junior developer does.

Code. Clients. Communication. Deployment. Testing. Invoices. Social media. All of it. Automatically. While you sleep.

The Real Problem With AI Coding Tools Today

Claude Code writes code. Devin writes code. Copilot writes code.

But writing code is maybe 40% of what a freelance developer actually does.

The other 60%?

Talking to clients. Understanding what they actually want.
Managing git properly. Branches, commits, PRs.
Running tests. Catching bugs before the client sees them.
Deploying to the right environment. Not accidentally pushing dev code to production.
Sending updates. "Hey, your feature is live."
Tracking costs. How much did this project actually cost me in API calls?
Following up. Drafting invoices. Scheduling calls.
Posting on LinkedIn about the work you just shipped.

No AI tool today handles all of that together. They give you a coding assistant and leave the rest to you.

AgentJr is different. AgentJr is not a coding assistant. It's a complete AI junior developer that manages your entire workflow — from the moment a client messages you, to the moment the project is deployed, tested, and the invoice is sent.

You Are the CEO. AgentJr Is the Manager.

Here's the architecture that makes AgentJr unique:

You — give direction. Set priorities. Approve plans. That's it.

AgentJr (Manager) — understands requirements, asks smart questions, builds plans, manages git, monitors work, handles client communication, runs tests, manages deployments, tracks costs, drafts invoices, posts social media updates.

Claude Code / Codex / Gemini CLI (Worker) — writes the actual code. Spawned by AgentJr on your terminal. Per project. You choose which one.

AgentJr never writes code itself. It orchestrates the worker that does. This separation is intentional — and it's what makes the whole system reliable.

How It Actually Works — The 21-Step Flow

Every project — from every client, from every channel — goes through the same complete flow:

Step 1 — Message arrives
A client messages you on WhatsApp, Telegram, Email, Slack, or the dashboard. AgentJr receives it immediately.

Step 2 — Content moderation
Is this a normal request? A frustrated client? An abusive message? AgentJr handles each differently — professionally, automatically.

Step 3 — Client check
Known client? Match to their existing project. New client? Ask you for approval first. Unknown contact — nothing happens without your sign-off.

Step 4 — Infinite Clarity Loop
AgentJr asks smart, context-aware questions — one by one — until it reaches 100% confidence. No assumptions. No hallucinated features. It asks about requirements, tech stack, edge cases, timeline, everything. The loop has no limit. It stops only when it's truly ready.

Step 5 — Cost + Timeline estimate
Before any plan, AgentJr auto-generates a cost and timeline estimate. You approve it. The client doesn't see it until you say so.

Step 6 — Client onboarding
New client? AgentJr welcomes them, collects their profile, sets their preferred notification channel. First impression handled professionally.

Step 7 — Plan Mode
AgentJr proposes a complete task breakdown with timeline estimates for each task. You review it. Modify it. Approve it. Not a single line of code gets written until you approve the plan. This is collaborative AI — not AI going rogue on your codebase.

Steps 8–10 — Project setup
Folder structure created. AGENT.md, MEMORY.md, SPEC.md generated. Git repo created or connected. Worktrees set up if parallel tasks needed. The correct vault (dev/staging/prod) injected automatically.

Step 11 — Spawn the coding worker
Claude Code, Codex, or Gemini CLI — whichever you configured for this project — spawns on your terminal. It works task by task, following the approved plan.

Steps 12–13 — Monitor + Auto-resume
AgentJr pipes stdout and stderr in real time. Pattern detection running. Watchdog active — if the coding worker goes silent for 60 minutes, AgentJr detects it, kills it, restarts it, resumes the same session. You don't have to watch anything.

Step 14 — Error handling
Error occurs? AgentJr tries to self-fix. If it can't, it retries via the coding worker. 10 retry limit. $5 cost guard. If still failing, it escalates to you — not before.

Step 15 — Security scan
After every single task — automatically — AgentJr scans the generated code. JWT checks. Rate limits. Access control. Every time. Not just at the end.

Steps 16–17 — Tests + Commit
Playwright MCP server runs browser tests on the live URL. Unlimited retry with cost guard. Tests pass? AgentJr commits to a branch — never directly to main. Tests fail? It goes back to fix, not forward to commit.

Steps 18–19 — Deploy + Health check
AgentJr asks you which environment. You say staging or prod. It deploys. Immediately runs a Playwright health check on the live URL. Health check fails? Auto rollback. You never have to manually rollback.

Steps 20–21 — Notify + Log
You get notified. Client gets notified on their preferred channel. Every task logged with screenshots, asciinema recordings, Playwright videos, and full cost tracking.

AgentJr Talks to Your Clients For You

This is where AgentJr goes far beyond any coding tool.

Your clients can message AgentJr directly — on Telegram, WhatsApp, Gmail, Slack, or Discord — and AgentJr responds as your junior developer.

Client on WhatsApp: "Hey, can you add a dark mode to the app?"
AgentJr: "Got it! Let me ask a few quick questions before I start..."

AgentJr introduces itself as a junior developer from your team. It's professional. It's patient. It handles the whole conversation.

It detects what language the client writes in — and replies in the same language automatically.

It knows when to be quiet. While work is happening, clients don't get spammed with updates. They get one message when the work is done and live.

It handles difficult clients too. Content moderation built in — abusive messages get flagged, you get alerted, and you decide whether to block.

Per-client settings: notification preferences, quiet hours, rate limiting, blacklist option. Every client handled exactly how you want.

Multiple Clients. Multiple Projects. Simultaneously.

Three clients message at the same time. Here's what happens:

Queue (BullMQ + Redis):
1. You (Browser, HIGH priority) → new project for Ali
2. Ahmed (WhatsApp, NORMAL) → add dark mode  
3. Sarah (Telegram, NORMAL) → fix login bug

AgentJr processes each in ~200ms.
Meanwhile, in the background:
- Terminal 1: Claude Code building Ahmed's dark mode
- Terminal 2: Claude Code fixing Sarah's login bug  
- Terminal 3: Ali's project in Clarity Loop

Nothing missed. Nothing blocked. Nothing confused.

Git worktrees handle parallel tasks on the same project too. Two features needed at once? Two separate worktrees. Two separate Claude Code instances. Both running. Both tracked. Both tested independently. Merged to main only after both pass.

The Memory That Never Forgets

AgentJr has three levels of memory — and they all stay forever:

AGENT.md — You write this. Your rules, your coding standards, your preferences, your client communication style. AgentJr follows them on every project.

MEMORY.md — AgentJr writes this automatically. Every project teaches AgentJr something. What worked. What didn't. What this client prefers. What this tech stack needs. It gets smarter with every project it completes.

Vector Search (FAISS) — Semantic search across all past context. "How did we handle authentication for that last project?" AgentJr finds it in seconds.

Three levels of hierarchy: Global → Project → Task. The right rules apply at the right scope. Always.

Your Secrets Are Safe

AgentJr has a 3-layer vault system. AES-256 encryption. .env files never permanently written to disk — injected at runtime, deleted after the task.

Layer 1: AgentJr's own keys. Your Claude API key, GitHub token, Telegram bot. Never accessible to projects.

Layer 2: Per-project, per-environment vaults. vault.dev.enc uses mock AI and fake payments. vault.staging.enc uses cheap models and test Stripe keys. vault.prod.enc uses your best model and real keys — with extra confirmation required before touching.

Layer 3: Mock mode. Testing costs zero. No real API calls. No real money.

Every inbound webhook is HMAC verified. GitHub, Stripe, custom — all verified before processing. Unverified request? 401 + logged + you get alerted.

Business Features Built In

AgentJr isn't just for code. It handles the business side too.

Social media — AgentJr drafts posts for LinkedIn, Twitter/X, Instagram, Facebook. Sends you the draft for approval. You approve, reject with feedback, or let it auto-post after 3 days. Posts go to all platforms simultaneously.

Invoicing — AgentJr drafts the invoice when a project is done. Stripe + PayPal supported. It never sends without your explicit CONFIRM. Always your call.

Lead generation — Apollo.io API integration. Legal. Targeted. You set the criteria.

Calendar — Google Calendar check before any scheduling. No blind booking.

Estimates — Cost and timeline estimate generated before any project starts. Yours to approve before the client ever sees it.

What's Under the Hood

For the technically curious:

Layer	Technology
AI Brain	LiteLLM — Claude, GPT-4o, Gemini, Groq, DeepSeek, Ollama, any model
Queue	BullMQ + Redis — 4 priority levels
Terminal UI	Ink.js — rich interactive CLI
Dashboard	Next.js + Socket.io — real-time web UI
Mobile	React Native + Expo — iOS + Android
Database	SQLite (local) + PostgreSQL (cloud)
Vector Memory	FAISS / Chroma
Testing	Playwright MCP Server
Encryption	AES-256
Process Manager	PM2 — 24/7 auto-restart
Observability	Prometheus metrics + optional Grafana
Extensions	MCP (13,000+ servers) + Skills + Hooks + Plugins

Model-agnostic by design. You bring your own API key. You choose the model per project. Complex project? Use Claude Opus. Simple task? Use Groq — fast and cheap. Offline? Ollama runs locally, free, private.

Smart fallback chain: primary model fails → fallback 1 → fallback 2 → local Ollama → notify you. AgentJr never stops because one provider is down.

One Dashboard. Everything Visible.

The browser dashboard (localhost:3000) shows everything in real time:

Live terminals for every active project
All client messages in one unified inbox — reply from the dashboard
Social media drafts waiting for your approval
Invoices waiting for your CONFIRM
Cost estimates pending approval
Background agents running silently
Token meter — live context usage per project
Per-project health scores
Full system logs, screenshots, Playwright videos

Shareable client links too. Token-based, 30-day expiry. Clients see their project status only — nothing else.

The Meta Strategy — AgentJr Builds Itself

After AgentJr launches open source, the plan is to use AgentJr itself to build the next three products:

AgentPro — Freelancer AI for agencies
Education Platform — AI-driven learning management
DevPulse AI — Developer performance monitoring

AgentJr building AgentPro in public — that's a story nobody else can tell. Living proof the tool works. That's the viral moment.

Free. Open Source. Forever.

AgentJr is MIT licensed. No subscription. No usage limits. No cloud dependency. No paid tier hiding features. Everything ships in the open source release.

You run it on your machine. Your code stays on your machine. Your clients talk to your instance. Your vault stays encrypted on your drive.

This is what developer tools should be.

Current Status

AgentJr is in active development. Core systems are being built and tested rigorously.

The plan is to test it thoroughly on real freelance projects for at least one month before open sourcing — because a tool that talks to your clients, touches your codebase, and manages your deployments has to be rock solid before anyone else runs it.

No release date announced. No hype. Just building.

When it's ready — GitHub and npm. Free. Open source.

Follow the Build

Twitter/X: @hamid_raza_agi — build updates in public
GitHub: github.com/muhammadhamidraza/agentjr — watch for the release
Dev.to: Follow me here — architecture deep-dives as each system ships

Built by Hamid Raza — Agentic AI & MERN Stack Developer

AgentJr — Your AI Junior Developer. Always Working.

I Built a Framework That Makes AI Ask Questions Before Writing Any Code

Muhammad Hamid Raza — Sat, 21 Mar 2026 21:39:20 +0000

I Built a Framework That Makes AI Ask Questions Before Writing Any Code

The Moment I Got Frustrated

I asked AI to build me an authentication system.

90 seconds later — 40 files generated.

3 months later — I had no idea how any of it worked.

I couldn't debug it. I couldn't extend it.
I was completely dependent on AI forever.

Sound familiar?

The Real Problem

AI coding tools are optimized for one thing: speed.

You say "add authentication"
AI immediately starts writing code.

But that's NOT how senior developers work.

A senior developer never opens their editor
the moment they hear a feature request.

They:

Ask questions — What exactly do you need?
Consider options — What are the trade-offs?
Surface edge cases — What could go wrong?
Plan architecture — How does it fit the system?
THEN write code — Only after all of the above

AI skips steps 1 through 4.

My Solution: Spec-Kit-CoLearn

I built Spec-Kit-CoLearn — a free open-source
framework that transforms any AI coding tool into
your senior architect co-partner first,
coding worker second.

Two Modes — One Tool

MODE 1: Senior Architect (Default)

When you start, AI enters Senior Architect Mode:

✅ Asks 3-6 discovery questions
✅ Presents 2-3 design options with trade-offs
✅ Teaches you concepts you don't know
✅ Surfaces at least 3 edge cases
✅ Defines measurable success criteria
❌ Does NOT write code in this mode

MODE 2: Coding Worker

Only activates AFTER you say "tasks approved":

✅ Executes tasks one by one in order
✅ Writes code matching spec exactly
✅ Runs tests after each task
✅ Stops and asks if scope changes

Why This Order Matters

WRONG: Code first → Realize it's wrong → Rewrite → Waste days
RIGHT: Think first → Spec → Plan → Tasks → Code once, code right

Teaching Mode — The Feature I'm Most Proud Of

This is what makes Spec-Kit-CoLearn unique.

You say: "I want users to log in"

AI doesn't write code. It teaches:

You mentioned authentication. Let me explain
your options before we design anything.

JWT is like a concert wristband.
You show your ID once at entry.
They give you a wristband.
You show the wristband everywhere inside.
No ID check again on every request.

Sessions store user data on the server.
More control. Instant logout possible.
But harder to scale.

OAuth lets users log in via Google or GitHub.
Less friction. You don't manage passwords.
But you depend on third-party.

Which fits your use case?

Now you've learned AND made an informed decision.

The Clarity Gate

Before ANY spec is written, AI must pass
a hard check — all 6 must pass:

✅ WHO is clear        — Who uses this feature?
✅ WHAT is clear       — What exactly does it do?
✅ SCOPE is defined    — What's IN and what's OUT?
✅ EDGE CASES covered  — At least 3 discussed
✅ SUCCESS measurable  — At least 2 measurable criteria
✅ YOU approved        — You explicitly said "approved"

If ANY item fails → more questions.
No gate passed = no spec written.
This alone saves weeks of rewrites.

The Learning Log

After every feature, AI generates a Learning Log:

## What You Learned:

| Term         | Definition                              |
|--------------|-----------------------------------------|
| JWT          | Stateless token for API authentication  |
| OAuth 2.0    | Third-party login protocol              |
| Sessions     | Server-side user state storage          |
| Bcrypt       | Password hashing with built-in salt     |
| httpOnly     | Cookie JavaScript cannot read (XSS safe)|

You don't just ship code — you ship understanding.

Full Workflow

1. pip install spec-kit-colearn
2. spec-kit-colearn init my-project
3. Open any AI coding tool
4. Paste activation prompt
5. Tell AI what you want (vague is fine!)
6. AI asks questions → teaches concepts
7. You choose from 3 options
8. Say "approved"
9. AI creates spec → plan → tasks
10. Say "tasks approved"
11. AI switches to Mode 2 → codes task by task
12. Learning log generated ✅

Install

# Python
pip install spec-kit-colearn

# JavaScript / Node
npm install -g @muhammad-hamid-raza/spec-kit-colearn

# Initialize project
spec-kit-colearn init my-project

Works With Every AI Tool

AI Tool	Support
Claude Code	✅
Codex CLI	✅
Gemini CLI	✅
GitHub Copilot	✅
Cursor	✅
Windsurf	✅
Qwen CLI	✅

Who Is This For?

Non-developers — Have ideas but can't code?
AI guides you step by step and teaches along the way.

Junior developers — Learn architecture, not just syntax.
Understand WHY before HOW.

Senior developers — Structured workflow, clear docs,
no more "just write it" chaos.

Links

⭐ GitHub: https://github.com/MuhammadHamidRaza/spec-kit-colearn
📦 PyPI: https://pypi.org/project/spec-kit-colearn
📦 npm: https://npmjs.com/package/@muhammad-hamid-raza/spec-kit-colearn

MIT license. Free forever. Contributions welcome.

Final Thought

AI should be your thinking partner.
Not just your code generator.

Build with clarity.
Ship with confidence.
Learn along the way.

Built with 🔥 from Pakistan 🇵🇰
Feedback welcome in the comments!