DEV Community: Henry Ohanga

Building Career Architect: An AI-Powered Job Application Pipeline for Engineers

Henry Ohanga — Sun, 11 Jan 2026 08:49:19 +0000

Introduction

As a software engineer, the job application process can feel like an endless cycle of customization. Tailoring resumes for each role, crafting cover letters that highlight the right experiences, and optimizing for Applicant Tracking Systems (ATS) — it's all time-consuming and repetitive.

But what if your AI coding assistant could handle it all? That's the promise of Career Architect, an open-source project I built to automate job applications using AI. Paste a job description, and let AI generate tailored materials that make you stand out.

In this technical deep dive, I'll explore how Career Architect works under the hood, its key features, and the architecture that makes it possible.

The Problem with Traditional Job Applications

Job hunting is inefficient by design:

Manual Customization: Every resume needs tweaking to match the job's requirements.
ATS Optimization: Keywords must be woven in naturally to pass automated filters.
Time-Intensive Process: Cover letters, interview prep, and follow-ups add up.

Engineers deserve better tools. Career Architect treats job applications as a system to optimize.

How Career Architect Works

The workflow is simple:

Paste Job Description: Provide the JD to your AI assistant.
AI Generates Materials: Tailored resume, cover letter, interview questions.
Build PDFs: Use LaTeX and Pandoc to create professional documents.

It's designed for AI assistants like Claude, GPT-4, or Copilot, making it an extension of your coding environment.

Key Features

Career Architect packs powerful features for modern engineers:

🤖 AI-Native Workflow: Integrates seamlessly with AI assistants for natural interaction.
📊 Metrics-Driven Resumes: Uses the SAR (Situation-Action-Result) framework for impactful achievements.
🎯 Vertical Targeting: Adapts tone for startups (bold), scale-ups (collaborative), or big tech (methodical).
📄 Multi-Format Export: Generate PDF, DOCX, TXT, and JSON from single Markdown sources.
🔍 Gap Analysis: Identifies skill gaps and suggests improvements.
🎤 Interview Prep: Generates likely questions with mock coaching.
📈 ATS Scoring: Analyzes keyword matches to optimize for ATS.
🌐 Web Dashboard: Streamlit-based UI for managing applications visually.
🔗 Job Board Scraping: Import from LinkedIn, Indeed, etc.
📦 Batch Processing: Handle multiple jobs at once.

Tech Stack

Built with Python at its core:

Python 3.8+: Core logic and scripting.
Streamlit: Web dashboard for visual management.
LaTeX + Pandoc: Document generation and conversion.
Rich & Click: Beautiful CLI with progress bars.
Requests + BeautifulSoup4: Job scraping.
Pytest + Flake8: Testing and linting.

External tools: Pandoc for format conversion, LaTeX for PDFs.

Architecture

The project follows a modular design:

Prompts (.prompts/): Markdown files guiding AI behavior for each task (e.g., resume tailoring, cover letters).
Scripts (scripts/): CLI tools for building, scraping, and analyzing.
Templates (templates/): LaTeX styles for different visual themes.
Source Materials (source_materials/): User's identity, resumes, projects.
Applications (applications/): Generated outputs per job.

The "Modern Builder" framework emphasizes metrics and high-agency language.

Code Examples

Setting Up Your Profile

In source_materials/identity.json:

{
  "full_name": "Your Name",
  "email": "your@email.com",
  "preferences": {
    "language": "en",
    "resume_style": "modern_builder",
    "template": "executive"
  }
}

CLI Usage

Create a new application:

python scripts/career.py new --company "Acme" --role "Senior Engineer"

Build documents:

python scripts/career.py build

Launch dashboard:

streamlit run app.py

Benefits

Time Savings: Automate hours of work.
Consistency: Standardized, professional outputs.
Optimization: ATS-friendly with gap analysis.
Scalability: Handle multiple applications effortlessly.

Conclusion

Career Architect empowers engineers to focus on coding, not paperwork. It's open-source, so contributions are welcome on GitHub.

Try it out: Clone the repo, paste a JD, and let AI architect your career moves.

If you're building AI tools for productivity, what challenges have you solved?

AI as a Collaborator: A Technical Manifesto for Builders

Henry Ohanga — Wed, 07 Jan 2026 11:00:18 +0000

How modern products, platforms, and teams must be designed, and what it actually takes to do it well.

For the last decade, the primary bottleneck in software was execution. Success was defined by speed to ship, reliability at scale, and the ability to hire enough engineering hands. That era is ending.

Across my work at Code Particles and advisory roles, one reality has become operationally clear:

Code is no longer the constraint. Judgment is.

AI has fundamentally changed how software is produced. But more importantly, it has changed what differentiates strong teams and technical leaders. This is a practical, technical assessment of where leverage now lives.

The Vignette: The Illusion of Velocity

A high-growth team integrates AI to accelerate a new product line. Within weeks, velocity metrics spike — PRs are flying, and the "lines of code" count is vertical. But three months in, a strange paralysis sets in.

Three different architectural patterns now coexist in the same service. No one is sure which is canonical. Bugs increase — not because the code is sloppy, but because the intent was never locked. The team is moving at 100mph, but they are driving in circles.

The fix wasn’t "less AI." The fix was restoring human judgment at the start and middle of the loop: defining constraints clearly and making explicit architectural decisions before letting the engines roar.

The Shift: From Software Engineering to System Leadership

AI has made one thing obvious: writing code is no longer the hardest part of building software. Today, a single developer can generate production-ready scaffolding, draft complex APIs, and explore multiple architectural approaches in parallel.

But velocity is not the same as progress. Most products still fail because AI removes the cost of execution but leaves the cost of bad decisions untouched. The modern bottleneck has shifted from implementation to three core leadership challenges:

Problem Selection: Choosing the right problems to solve.
Boundary Definition: Designing the "seams" and interfaces between services.
System Durability: Building architectures that survive scale, human turnover, and time.

Then vs Now

Then, success meant shipping features, closing tickets, and scaling headcount. Architecture emerged organically. Today, success means constraining systems, reducing decision noise, and scaling judgement, and architecture is an explicit, continuously defended asset.

“AI as a Collaborator” is a Discipline

Most teams misunderstand this phrase. AI collaboration is not about delegating thinking or shipping faster without accountability. It is a design for a workflow where:

Humans own Intent: The "Why," the judgment, and the final call.
Machines own Exploration: The "How," the drafts, and the brute-force execution.
Systems own Verification: The continuous check against reality and requirements.

Where AI Should Not Lead: The Non-Negotiable Human Core

Not every surface should be AI-accelerated. While AI is a world-class explorer, it is a poor custodian of irreversibility. Core business logic, security-critical paths, and high-stakes migrations require a "slower," human-led design process.

Speed in the wrong place creates structural risks that no refactor can undo. You must keep a human "hand on the wheel" for:

The "Ground Truth" Logic: The code that defines your unique competitive advantage or regulatory compliance.
Irreversible State Changes: Database migrations, destructive API changes, or multi-service deployments where a "rollback" isn't a simple button-press.
The Security Perimeter: Authentication flows, encryption handshakes, and permission models. AI excels at boilerplate, but it lacks the adversarial mindset required to defend against novel exploits.

Rule of Thumb: If a mistake in this file could end the company or result in a lawsuit, it is a human-led territory.

The Failure Mode: Entropy-by-AI

The most frequent failure I see today is Entropy-by-AI. When implementation becomes "free," the natural friction that usually keeps a codebase lean disappears. Without that friction, teams tend to over-produce.

Codebases begin to expand faster than the team’s shared mental model. AI removes the cost of producing artifacts, but it does not remove the cost of choosing poorly. If you cannot explain why your system looks the way it does, you have already lost control.

Key Characteristics of AI-Driven Overproduction:

Architectural Fragmentation: Teams generate multiple patterns (e.g., three different ways to handle async jobs) instead of committing to one.
PR Bloat: Pull requests grow larger and more complex, yet the "description" field stays vague because the human didn't write the logic.
The "Black Box" Effect: Knowledge siloes form around specific AI threads. No one can explain the "magic" functions that now power core features.
Ghost Dependencies: AI frequently pulls in heavy libraries or " textbook" fixes that aren't tailored to your specific infrastructure, adding unnecessary weight.

Final Polish: The "Decision Throughput" Metric

To close the gap, we must shift our internal metrics. If we measure Velocity (lines of code, number of PRs), we incentivize entropy. If we measure Decision Throughput — the rate at which a team can make a high-quality, verified architectural choice — we incentivize leadership.

The teams that thrive won't be the ones that ship the most code; they’ll be the ones that maintain the most clarity.

The Practical Collaboration Loop

To combat entropy, elite teams follow a strict 5-step loop:

Human sets Intent & Constraints: Defining the goals, invariants, and non-negotiables.
AI Explores Options: Drafting architectures, patterns, and alternatives.
Human Selects Direction: Evaluating trade-offs explicitly and "locking" the path.
AI Executes within Boundaries: Writing the code, generating tests, and refactors.
Human Validates: Testing against real-world users, metrics, and failure cases.

The Five Capabilities of the Modern Builder

1. Precise Problem Decomposition

AI amplifies clarity but punishes ambiguity. High-leverage builders translate vague business goals into technical problems by defining inputs, outputs, and failure modes.

2. Systems Thinking over Feature Thinking

Features are easy; systems are hard. AI can build a component, but only a human can design the interaction between state, data flow, and unintended consequences under real-world pressure.

Problem selection is as much a product discipline as a technical one: choosing what not to build is often the highest-leverage decision a team makes.

3. AI Steering, Not Prompting

Prompting is table stakes; steering is leadership. It is the ability to detect when an output is “subtly wrong” and cross-check it against domain context. Think of AI as an extremely fast junior engineer: it will produce impressive work — confidently — even when it is wrong. Your value lies in knowing the difference.

4. Technical Taste

As execution becomes cheap, taste is the ultimate filter. Taste is choosing simplicity over cleverness and knowing when to say "no" to an unnecessary abstraction.

5. Ownership of Outcomes

You are no longer paid for writing code; you are paid for systems that work. This is the dividing line between a contributor and an owner.

The New Frontiers: What We Didn’t See Coming

To build a manifesto for the future, we must address the “hidden” challenges of the AI era:

The Mentorship Gap If AI is a “highly capable junior,” how do human juniors learn? We must redefine mentorship. Senior engineers can no longer just review code; they must review decision logic. We must teach juniors how to “steer” and “verify” rather than just “write.”
The Verification Paradox Writing code is now 10x faster, but reading and verifying code is just as slow as it has ever been. To avoid “quality debt,” automated testing and formal verification are no longer optional — they are the only way to scale without the system collapsing under its own unverified weight.
Architecture as the “Source of Truth” When AI can rewrite a codebase in an afternoon, the code itself becomes ephemeral. The durable core of a project is now its Interfaces and Data Contracts. If your boundaries are solid, the implementation can be fluid.
The Economic Reality: The “Elite Pair” We are moving away from massive “two-pizza” teams toward Elite Pairs: One Human Architect and an AI Agent. The unit of value has shifted from Sprint Velocity to Decision Throughput. In practice, this already shows up in small, high-leverage teams shipping systems once reserved for entire departments.

The New Stakes for Organizations

For Startups: AI compresses time-to-market. However, speed without judgment leads to fragile systems. Startups win by making fewer, higher-quality decisions.
For Scale-ups: Complexity compounds. AI increases the technical surface area. Scale-ups need leaders who can rein in entropy and align product intent with engineering reality.
For Big Tech: Differentiation shifts to architecture quality and decision velocity. Large organizations that fail to adapt will be eroded from within by their own unmanaged complexity.

The Operational Playbook

The AI-Augmented Engineering Maturity Model

Capability	Level 1: Reactive	Level 2: Proactive	Level 3: Strategic
Decomposition	Breaks tickets into tasks.	Translates features into specs.	Reframes problems to minimize complexity.
Systems Thinking	Focuses on local logic.	Considers scaling / edge cases.	Reasons about state and feedback loops.
AI Steering	Accepts first output.	Refines prompts for patterns.	Cross-checks assumptions; enforces constraints.
Ownership	Outcome: "Ticket is Done."	Outcome: "Feature is Shipped."	Outcome: "System delivers durable value."

Hiring for the AI Era: The "System Leadership" Interview

The Decomposition Prompt: Ask for the technical invariants of a vague requirement before any code is written.
The Subtle Bug Review: Give them AI-generated code with a fundamental architectural flaw. See if they trust the "looks right" factor or apply rigorous logic.
The Simplicity Trade-off: Ask what they have intentionally said "no" to in the past to save a system from complexity.

Where I Operate in This Shift

Across my advisory work, my focus sits at the intersection of product strategy, system design, and AI-augmented engineering workflows. Most engagements begin with a System-Level Review:

How are decisions currently made?
Where is AI being introduced (and where should it stay away)?
Where is judgment leaking into ambiguity?
Which constraints actually matter for your specific market?

I operate as a system-level partner: aligning intent, architecture, and AI workflows before complexity hardens into debt. My value is not in producing code faster. It is in helping teams ask the right questions and design systems that humans and machines can collaborate on effectively.

Conclusion: The Real Competitive Advantage

In the coming years, the strongest teams will not be defined by their tech stack or their AI tools. They will be defined by Clarity of Intent, Quality of Decisions, and Strength of Systems.

The question is no longer, "Can we build this?" It is, "Is this the right system to build — and can we own it end-to-end?" The teams that get this right will move faster with fewer people and fewer rewrites. The rest will ship more — and understand less. That difference is where leverage now lives.

I Built an AI-Powered Job Application Factory (And You Can Too)

Henry Ohanga — Wed, 07 Jan 2026 10:37:41 +0000

TL;DR: I got tired of spending 2+ hours customizing each job application. So I built an open-source system that lets AI do 90% of the work. Paste a job description, get a tailored resume, cover letter, and interview prep in minutes.

The Problem Every Engineer Knows Too Well

It's 11 PM. You've found your dream job posting. The deadline is tomorrow.

You open your resume. You stare at it. You think: "How do I make my payment system experience sound relevant to their recommendation engine team?"

Three hours later, you've:

Rewritten 6 bullet points
Googled "action verbs for resumes" twice
Questioned every career choice you've ever made
Still haven't started the cover letter

Sound familiar?

I was doing this dance 3-4 times a week during my last job search. Each application took 2-3 hours of mentally exhausting work. And the worst part? I wasn't even sure if my "customizations" were actually improving my chances.

So I did what any engineer would do: I automated it.

Introducing Career Architect 🏗️

Career Architect is an open-source, AI-powered job application pipeline. Here's the workflow:

1. Paste job description  →  2. AI generates everything  →  3. Build PDF

That's it. That's the whole process.

What you get:

✅ A tailored resume with metrics that match the job requirements
✅ A cover letter that complements (not duplicates) your resume
✅ Interview prep with likely questions and model answers
✅ ATS keyword scoring to optimize your match rate
✅ Professional PDFs ready to submit

Time investment: ~10 minutes of review instead of 2+ hours of writing.

How It Actually Works

The "Experience Lake" Concept

The magic starts with what I call your Experience Lake — a comprehensive markdown file containing every achievement, project, and metric from your career.

Instead of trying to remember that time you "improved API latency by 40%" while staring at a blank resume, you build this lake once. The AI then fishes from it for each application, pulling the most relevant catches.

# Master Experience

## Payment Platform (2022-2024)
- Architected distributed payment system processing 50K daily transactions
- Reduced checkout latency from 800ms to 120ms (85% improvement)
- Led team of 4 engineers, improving sprint velocity by 35%

## Real-time Analytics (2021-2022)
- Built streaming pipeline handling 1M events/minute
- Implemented anomaly detection reducing fraud by 23%
...

The Prompt Orchestra

Career Architect uses a series of specialized AI prompts that work together:

Prompt	Job
`analyser.md`	Gap analysis — what you have vs. what they want
`tailor_resume.md`	Generates targeted resume from your experience lake
`cover_letter.md`	Writes a compelling narrative
`interview_prep.md`	Predicts questions with model answers
`pdf_generator.md`	Validates and prepares for PDF export

Each prompt has a specific role, like musicians in an orchestra. The main_orchestrator.md conducts them all.

Vertical Targeting

Not all companies speak the same language. A startup wants to hear about your "zero-to-one wins" and "force multiplier" impact. Big Tech wants "scale," "precision," and "methodical approaches."

Career Architect automatically detects company size and adjusts tone:

Company Type	Tone	Keywords
🚀 Startup (<50)	Bold, high-energy	"Shipped," "Owned," "10x'd"
📈 ScaleUp (50-1000)	Collaborative	"Scaled," "Processes," "Cross-functional"
🏢 Big Tech (1000+)	Methodical, precise	"At scale," "Systems," "Reliability"

The Technical Stack

Career Architect is surprisingly simple:

Python — CLI tools and scripts
Markdown — All documents are plain text
Pandoc + LaTeX — Beautiful PDF generation
Your AI assistant — Claude, GPT-4, Copilot, whatever you use

No databases. No cloud services. No subscriptions. Everything runs locally on your machine.

Template Gallery

Four professional LaTeX templates included:

Template	Best For
Default	Modern tech companies (slate blue)
Minimal	Traditional industries (black & white)
Creative	Startups and design roles (bold colors)
Executive	Senior/management positions (navy & gold)

Real Results

After using this system for 3 months:

Application time: 2.5 hours → 15 minutes (per application)
Response rate: Increased ~40% (more tailored = more callbacks)
Interview prep: Actually prepared instead of winging it
Mental load: Dramatically reduced

The biggest win? Consistency. Every application is now professionally formatted, keyword-optimized, and genuinely tailored. No more "good enough" submissions at midnight.

The Philosophy: Modern Builder

Career Architect includes an optional "Modern Builder" framework for presenting engineering experience. It's based on five core capabilities:

Precise Problem Decomposition — Breaking complex problems into solvable units
Systems Thinking — Understanding interconnections and dependencies
AI Steering — Effectively directing AI tools for development
Technical Taste — Making sound architectural decisions
Ownership of Outcomes — End-to-end responsibility for results

Instead of saying "Implemented payment system," you'd say "Locked architectural intent for payment flows, reducing integration entropy across 4 downstream services."

It's a different way of communicating engineering value. Use it if it resonates, skip it if it doesn't.

Getting Started (5 Minutes)

# Clone the repo
git clone https://github.com/henryohanga/career-architect.git
cd career-architect

# Set up virtual environment
python -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install -r requirements.txt

# Verify setup
make check

Then:

Add your contact info to source_materials/identity.json
Paste your existing resumes into source_materials/resumes/
Tell your AI assistant: "Read .prompts/setup.md and build my experience lake"

For each new application:

Paste the job description
Say: "Use the Career Architect pipeline"
Review the generated materials
Run make build for PDFs

Why Open Source?

Job hunting is stressful enough. Everyone deserves access to tools that level the playing field.

Career Architect is MIT licensed. Use it, fork it, improve it. If you build something cool on top of it, I'd love to hear about it.

What's Next?

Some ideas I'm exploring:

LinkedIn integration — Auto-optimize your profile for target roles
Application tracking — Built-in CRM for your job search
Interview simulator — Practice with AI before the real thing
Salary negotiation coach — Data-driven negotiation strategies

But honestly? The core system works. It's been battle-tested through dozens of real applications.

Final Thoughts

The job market is competitive. Companies use AI to screen resumes. It's only fair that candidates use AI to create them.

Career Architect doesn't write fiction about your experience. It presents your actual achievements in the best possible light for each specific opportunity. That's not gaming the system — that's effective communication.

If you're an engineer tired of the resume grind, give it a try. Your 11 PM self will thank you.

🔗 Links:

GitHub: github.com/henryohanga/career-architect
License: MIT (free forever)

💬 Questions? Open an issue or reach out. Happy to help.

If this helped you land an interview, let me know. Nothing makes an open-source maintainer happier than hearing their tool actually worked. 🎯