My agentic coding Tech Stack - February 2026

TL;DR Version

This is the process I use for coding with Claude Code in a greenfield project.

I use these 4 pillars and tools:

1. Understand the problem and create a solid plan (business and tech stack): gemini and notebookllm for brainstorming

2. Track the tasks: Backlogmd

3. Revert unwanted changes: git

4. Use the best coding model: Claude Code

Use this new technology to learn, to get better at coding, to be more efficient and to ask as many questions as needed. After all, this is where the future is heading towards, why not be a part of it?

IMPORTANT: do NOT vibe-code the project. Use the LLMs as both a teacher and worker. Ask questions, test yourself, do deeper research yourself, and learn a skill from each project you do.

Step 1: How to find a cool project idea

This is the easiest part! The key is to solve your own problems using technology while learning and having fun.

I swear that building stuff, testing technologies and learning are my favorite things to do. Dopamine hit after dopamine hit :-). After all, I’ve built a solid career out of it.

Here is how I come up with (some) project ideas:

• I took a seven month parental leave when my son was 6 months old > I came out with Baby Safe Scan, an app which uses Computer Vision to detect objects dangerous to babies in images.

• No more space for pictures on my iPhone > Photo Organizer to save my pictures locally, filter them, order them by month, etc.

• I wanted to apply for a new job and create a new resume > I created “Axiom CV” (will be released soon as open-source), an agent which reformats your resume specifically for the German market.

• Wanted to understand how a multi-modal RAG System works > I implemented the ColPali Research paper in the Visual RAG app.

And many more.

Step 2: Write down the initial project instructions

Here is where I start using Backlogmd for creating the first task. This will be my first epic and it contains: the project objective, important milestones/steps and tech stack.

I define the project objective:

This project is used as a Visual RAG for retrieving information from both text and images from .pdf files.

- Use this technology for the retrieval

- Use this Vector Database for storing the embeddings

- Use this framework for the architecture

- Here is documentation: <link>

You can take a look at this example from the Visual RAG app.

Step 3: Write the coding instructions for the agent

If you are not familiar with the Claude.md file, take a look at this Youtube Video where an Anthropic developer explains how Claude Code works. Basically the content from the Claude.md file is always sent to Claude Code.

For all other agents (Cursor, OpenCode, etc) use the standard Agents.md.

I always cover the following:

  - Project goal — a one-liner so the agent understands what it's building
  - Project structure — where to find the backend, models, tests, tasks, etc.
  - Coding standards — error handling, type hints, no comments, services for business logic, Pydantic for all data flows
  - Tooling — linting rules (ruff), how to run scripts (uv), how to run tests (make commands)
  - Guardrails — things the agent should never do without asking (change model params, commit code, create tasks)
  - Environment — key env vars so the agent doesn't have to guess configuration

# Visual RAG — Visual Retrieval-Augmented Generation with ColPali + Milvus

## Project Goal

This project is used as a Visual RAG for retrieving information from both text and images from .pdf files.

## Project Structure

src/ app.py # FastAPI application setup (lifespan, CORS, router) api/v1/ # API endpoints (ingest, search, generate, documents) core/ # Config (Pydantic Settings), model loader (singleton) models/ # Pydantic request/response models services/ # All business logic (embedding, ingestion, milvus, search, generation, pdf) utils/ # Shared helpers (image utils, document utils) tests/ # Mirrors src/ structure (api/, services/, utils/) backlog/ # Task management (Backlog.md format) data/ # PDF documents, generated images, temp files

## General Code Standards

- No docstrings, no comments (unless logic is non-obvious)
- Small, focused functions — break large functions into smaller ones
- No business logic in routers — use services and utils
- Use error handling in all generated code


## Python Style

### Package Manager
- Use `uv` for everything: running scripts, tests, adding dependencies
- `uv add <library>` to install — never edit pyproject.toml manually
- `uv run pytest` to run tests
...

Take a look at this example.

Why Use Claude.md and not the Agent Skills?

Because it’s more efficient — Vercel did an experiment regarding this, and the results were astonishingly good for the Agents.md vs. Agent skills.

Step 4: Make Claude Code create the first stories

Here I use Claude Code, reference the epic and tell it to create the stories using the Backlogmd tool:

Read the epic '@task-001 plan for visual RAG PoC' and break it down into stories.

Step 5: Git

This step is the most important one, because we don’t want to break the application if Claude Code starts making changes and breaking stuff.

After every piece of successful work, which is usually a task in Backlogmd, I manually test it and afterwards I do a commit.

My commit messages look something like this:

Task-002 Foundational Setup:
    - Create folder structure for FastAPI project
    - Create .gitignore
    - Create config.py for configuration

• (Optional) Create a branch for each story, but I don’t think this is necessary.

Step 6: Debugging

Testing the logic line-by-line is the best way to hold the control.

This step is where the learning happens: understand the technology, find bugs and see the code quality.

If something doesn’t look right, ask the agent, adapt the Claude.md file, create a new Backlogmd task.

Since I started using VSCode as an IDE I install the Python Plugin and use this configuration for my FastAPI backend.

Here is an example for debugging in VSCode a FastAPI application using the uvicorn server.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python Debugger: FastAPI",
            "type": "debugpy",
            "request": "launch",
            "module": "uvicorn",
            "args": [
                "src.app:app",
                "--reload"
            ],
            "jinja": true
        }
    ]
}

← Back to home