DEV Community: Brian Koech

I Built ContextForge with Gemma 4: A Project Memory Generator for Developers and AI Coding Agents

Brian Koech — Sat, 23 May 2026 11:06:00 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4.

What I Built

ContextForge is a developer tool that scans a codebase and generates practical, AI-ready project documentation using Gemma 4 through the Gemini API.

The goal is simple: when a developer or AI coding agent opens a project, they should not have to rediscover the whole repository from scratch. ContextForge generates README.md, SETUP.md, ARCHITECTURE.md, and especially AGENT.md, a durable handoff file designed for future AI coding sessions.

The problem: AI coding agents lose context

AI coding agents are useful, but their context is fragile.

When a chat is cleared, a session expires, or a different agent starts working on the same repository, a lot of hard-won project understanding disappears:

what framework the app uses
which files matter most
how to run the project locally
what generated folders should be ignored
what assumptions are still uncertain
what safety rules an agent should follow before editing

Traditional README files help humans, but they are not always enough for AI agents. Agents need a project map, editing constraints, validation steps, and warnings about risky areas.

That is why ContextForge focuses on AGENT.md.

What ContextForge does

ContextForge takes a ZIP upload or a built-in sample project and generates documentation from the actual files in the codebase.

The MVP can:

upload a ZIP file
load a built-in Django sample project
safely extract and scan files
ignore folders like .git, node_modules, .venv, dist, build, .next, and coverage
detect the tech stack
build a structured prompt for Gemma 4
generate:
- README.md
- AGENT.md
- SETUP.md
- ARCHITECTURE.md
display generated docs in tabs
copy each generated document
download all generated docs as a ZIP

The output is meant to be practical rather than marketing-heavy. If ContextForge is unsure about something, the prompt asks the model to mark that uncertainty instead of inventing details.

Demo

The project is available on GitHub and can be run locally with Docker Compose:

git clone https://github.com/bryko254/contextforge.git
cd contextforge
cp backend/.env.example backend/.env
cp frontend/.env.example frontend/.env
docker compose up --build

Then open http://localhost:5173.

The judge-friendly demo flow is:

Open the ContextForge frontend.
Click Try sample project.
The backend scans the built-in Django task API sample.
ContextForge detects Python, Django, PostgreSQL, Docker, and pip.
The app asks Gemma 4 to generate docs.
The UI displays:
- README.md
- AGENT.md
- SETUP.md
- ARCHITECTURE.md
Open AGENT.md and show the AI-agent-focused project handoff.
Copy a generated document.
Download all docs as a ZIP.
Optionally upload a small ZIP project and run the same flow.

The app also supports mock mode, so the UI can be tested without a Gemini API key. For judging the real AI flow, run with USE_MOCK_AI=false and provide GEMINI_API_KEY.

Code

Repository: https://github.com/bryko254/contextforge

The project is structured as a small full-stack app:

backend/: FastAPI API, ZIP handling, scanning, stack detection, prompt construction, and Gemma API client.
frontend/: React/Vite UI for uploads, sample generation, document tabs, copy buttons, and ZIP export.
sample-projects/django-api-demo/: built-in Django REST Framework sample used for the default demo.
docs/dev-to-submission-draft.md: this DEV submission draft.

How I Used Gemma 4

ContextForge uses gemma-4-26b-a4b-it through the Gemini API. I chose this model because ContextForge is not trying to write arbitrary code; it is doing structured documentation synthesis over selected codebase context.

The model needs to:

read selected project files
follow a strict JSON response schema
avoid inventing dependencies
summarize architecture clearly
generate instructions for both humans and AI coding agents

Gemma 4 works well for this kind of grounded, instruction-following task. The hosted demo uses the Gemini API so judges can try the app without running a local model.

The architecture is intentionally isolated behind a gemma_client.py service, so the project can later support local Gemma 4 inference for private repositories.

The Gemma 4 call is at the heart of the pipeline:

The backend scans selected files from the uploaded or sample project.
The scanner filters out large, generated, binary, and irrelevant files.
Stack detection summarizes languages, frameworks, databases, infrastructure, and package managers.
ContextForge builds a structured prompt with file summaries, selected file content, and safety rules.
Gemma 4 returns valid JSON containing readme, agent_md, setup, architecture, and summary.
The backend validates the JSON schema before returning it to the frontend.

Architecture

The app has a small full-stack architecture:

User
  |
  | ZIP upload or sample project
  v
React + Vite frontend
  |
  | HTTP request
  v
FastAPI backend
  |
  | safe ZIP extraction / sample project path
  v
Scanner
  |
  | selected files + file tree
  v
Stack detector
  |
  | structured stack summary
  v
Prompt builder
  |
  | documentation prompt
  v
Gemma 4 via Gemini API
  |
  | JSON response
  v
Generated docs UI

The backend is responsible for file handling, scan limits, prompt construction, and API calls. The frontend is responsible for upload controls, loading states, docs tabs, copy buttons, and ZIP download.

How the codebase scanner works

The scanner is intentionally simple and safe for an MVP.

It walks an extracted project directory recursively and ignores noisy or risky paths, including:

.git
node_modules
venv
.venv
__pycache__
dist
build
vendor
.next
.turbo
coverage

It also skips binary and large files such as databases, images, PDFs, and ZIPs.

The scanner only reads text/code files and applies limits:

maximum individual file size: 80KB
maximum collected content: about 300KB

Important files are prioritized, including:

README.md
package.json
requirements.txt
pyproject.toml
Dockerfile
docker-compose.yml
manage.py
settings.py
urls.py
models.py
views.py
serializers.py
folders like src, app, and routes

The scanner returns a file tree summary, selected file contents, skipped file count, and total collected size.

How AGENT.md is generated

AGENT.md is generated from the same scan context as the other docs, but the prompt gives it a specific job.

It asks Gemma 4 to write AGENT.md for future AI coding agents. That means the output should include:

project map
important directories and files
setup and validation guidance
safe development rules
uncertain assumptions
areas that need extra caution

This is the core idea behind ContextForge: make project context durable across AI coding sessions.

For example, after a chat is cleared, the next agent can open AGENT.md and immediately understand how to move safely inside the repository.

Challenges faced

The biggest challenge was deciding how much code context to send to the model.

Sending everything is risky and inefficient. Sending too little gives weak documentation. The MVP solves this with a scanner that prioritizes important files, skips generated/binary folders, and keeps a strict total content limit.

Another challenge was making the model output predictable. ContextForge asks Gemma 4 for valid JSON with a fixed schema, then the backend validates that response before sending it to the frontend.

I also had to handle security basics around ZIP uploads. The backend checks for path traversal before extracting archives and cleans temporary folders after processing.

Finally, I wanted the project to work without a real API key during local testing, so I added USE_MOCK_AI=true.

What I would improve next

Next improvements I would make:

add GitHub repository cloning from the frontend
support local Gemma 4 inference for private repositories
add richer language-specific parsing
generate docs from diffs after code changes
add server-side history for generated docs
support more output formats for different agent ecosystems
improve prompt compression for large repositories
add background jobs for larger scans

The local inference path is especially important. The hosted demo uses Gemini API for easy judging, but private repositories should eventually be able to use local Gemma 4 inference without sending selected code context to an external API.

Stop Building Manual Quotes: Meet the Agentic Workflow for Kenyan Freelancers

Brian Koech — Tue, 17 Feb 2026 15:47:01 +0000

As developers, we hate repetitive CRUD work. Yet, every time we land a freelance gig, we spend an hour wrestling with Word docs or generic invoicing SaaS that doesn't understand M-Pesa or local business logic.

I’m excited to share how we're using Agentic AI at BetterQuotes to turn "billing" from a chore into a single prompt.
🤖 What is an "Agentic" Quote Agent?
Most invoicing tools are just "digital paper." You click, you type, you save.

An Agentic Agent is different. It doesn't just store data; it carries out an intent. It understands context, applies business rules, and executes multi-step workflows.

Inside BetterQuotes, the agent allows you to skip the menus. Instead of clicking "New Quote" -> "Add Client" -> "Add Item," you can interact with a system that:

Reasons through your request: "Create a quote for a 3-month React Native project for Safaricom, total 450k, split into 3 milestones."

Applies Logic: It automatically calculates the KES totals, formats the milestones, and attaches your branded header.

Closes the Loop: With one confirmation, it pushes the quote to the client and sets up the M-Pesa STK Push trigger for the deposit.

We built this with a "Dev-First" mindset:

Context-Aware: The agent remembers your common service rates and client preferences.

M-Pesa Integration (The Killer Feature): No more "Send me the screenshot" or manual reconciliation. The agent tracks the payment status via M-Pesa API in real-time.

Branding without the CSS: You get professional, high-fidelity PDFs and web-views without touching a design tool

The goal of BetterQuotes isn't just to "make quotes." It's to build a Business OS for the Kenyan ecosystem. Whether you’re a solo dev or running a small agency, you can now manage your team and your cash flow using a tool that feels as smart as the code you write

Standard-Bearer AI: Making Company Standards Conversational

Brian Koech — Tue, 27 Jan 2026 18:23:52 +0000

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Conversational Experiences

Demo

What I Built

Project Link:
Live Demo: https://algosearch-alpha.vercel.app/
GitHub Repository: https://github.com/bryko254/algosearch

The Problem

🛡️
In my experience as a developer, I've seen internal coding standards buried in static PDFs, Confluence pages, or READMEs that nobody reads. This leads to "technical debt by accident"—developers want to follow the rules, but finding them is a chore. When information "foraging" is too hard, consistency dies

The Solution: Standard-Bearer AI

🤖
Standard-Bearer AI transforms stagnant documentation into a proactive architectural mentor. Built using Algolia Agent Studio, it allows developers to ask natural language questions and receive precise, company-sanctioned answers instantly.

Instead of browsing through a list of search links, the developer gets the exact answer extracted from the source of truth

How I Used Algolia Agent Studio

1. The Knowledge Base (Algolia Index)
I created a structured JSON index containing core standards for:

Python Style Guides (PEP 8)
Conventional Commits
Security & API Key Management
Database Migration Policies

2. The Brain (Agent Studio)
Using Algolia Agent Studio, I configured a "Standard-Bearer" agent. I implemented a strict System Prompt to ensure the AI acts as a "source of truth" guardian. It is instructed to only answer based on the indexed data, effectively eliminating hallucinations

3. The Experience (Frontend)
The frontend is a modern Vite application using InstantSearch.js. I integrated the new InstantSearch chat widget, which provides the conversational bridge to the Agent.

Auto-open Logic: The widget automatically greets the developer on load, reducing the friction to start a query.

Visual Cues: I added a custom mutation observer to show animated loading states while the AI is "thinking" and retrieving documentation

Why Fast Retrieval Matters

In a documentation context, latency is the enemy of adoption. If a developer has to wait 10 seconds for a search result or an AI response, they will simply stop using the tool and go back to guessing—or worse, following outdated patterns

**Reliable RAG (Retrieval-Augmented Generation): Fast retrieval allows the Agent to perform multiple lookups if necessary, ensuring that the AI’s response is always grounded in the most relevant, up-to-date documentation

Technical Architecture *🧠
*User Query: "How should I name my Python classes?"

Retrieval: Algolia searches the internal_documentation index for the "Python Style Guide" record.

Augmentation: The text "Use PascalCase for classes" is fed to the Agent.

Generation: The Agent Studio LLM synthesizes a helpful response: "According to our standards, you should use PascalCase for classes."

Team Members:
@brykoech254 Brian Koech

DEV Community: Brian Koech

I Built ContextForge with Gemma 4: A Project Memory Generator for Developers and AI Coding Agents

What I Built

The problem: AI coding agents lose context

What ContextForge does

Demo

Code

How I Used Gemma 4

Architecture

How the codebase scanner works

How AGENT.md is generated

Challenges faced

What I would improve next

Stop Building Manual Quotes: Meet the Agentic Workflow for Kenyan Freelancers

Standard-Bearer AI: Making Company Standards Conversational

Demo

What I Built

*The Problem *

*The Solution: Standard-Bearer AI *

How I Used Algolia Agent Studio

Why Fast Retrieval Matters

The Problem

The Solution: Standard-Bearer AI