Skip to main content

Introduction

contextFirst Hero

About contextFirst

A context-first system that keeps architecture, intent, and product decisions aligned across AI development sessions.

contextFirst is a proposal for disciplined AI engineering. It is not a rigid product, but an agnostic framework that you can activate to bring structure to Gen-AI chaos in your software projects. Once active, the AI assistant guides you to keep mental load to a minimum while significantly improving your software quality and process predictability.

It helps you maintain ownership of your codebase by ensuring that your AI assistant (Cursor, Copilot, Windsurf) respects your architecture and product intent - even weeks into a project.

"Context Awareness is what keeps AI aligned over time."

Magic Moment

Don't worry about writing documentation manually. The AI acts as your scribe, interviewing you to generate the necessary context files (Project Brief, Specs) automatically before writing a single line of code.

The Reality Check: Why "Magic" Breaks​

Building software with AI feels magical at first. It’s like "Vibe Coding" (a la Lovable/v0) - fast, visual, and impressive.

But purely generative coding is Debt-on-Demand.

  • The codebase becomes a black box you are afraid to touch.
  • The AI forgets its own decisions from yesterday.
  • You trade Construction Time (fast) for Debugging Time (slow).

If AI is a Ferrari engine, contextFirst is the steering wheel. Without it, adding more power (better models) just means you crash faster.

The Missing Piece: Context​

This is not a library or a rigid SaaS product. It is a methodology for your AI Editor.

It creates a "Constitution" that forces the AI to behave like a Senior Engineer rather than an impulsive Junior.

Comparison"Vibe Coding" / ChatcontextFirst
Mindset"Generate this for me.""Limit the scope to this."
AnalogyA Freelancer who ghosts you.A Partner who documents everything.
OutcomeA demo that breaks tomorrow.A product that scales.
LogicImplicit ("Guess what I want")Explicit ("Refuse until I spec it")

Strategic Fit​

This approach is meant as an operating model for professionals prioritizing long-term stability over short-term speed.

RoleWhy this matters
Senior Developers & FoundersActs as an architectural memory layer. It prevents you from explaining the same context twice, allowing you to operate as a CTO rather than just a coder.
Engineering LeadsMitigates "architectural drift". The system enforces your established patterns and design principles before any new code is written.
Product ManagersTurns requirements into strict constraints. Your product definitions actively steer the implementation, closing the gap between intent and execution.

The Trade-off: You invest 5% more effort in defining intent to gain stability and sustained velocity as complexity grows.

The Strategy: Manage the Machine​

As a Senior Leader, you know that typing code is the cheapest part of development. The scarce resources are Clarity, Architecture, and Consistency.

This kit enforces a "Managerial Loop":

  1. Define Context: No code is written without a Project Brief. Use the AI to interview you, not just to output code.
  2. Enforce Quality: The AI actively checks Standards before proposing solutions. It is allowed to challenge you.
  3. Capture Knowledge: Mistakes are recorded in Lessons Learned. We don't solve the same bug twice.

"It turns the AI from a text generator into a systems thinker."

A Personal Note​

I developed this system for myself over the course of 3 years working intensively with AI-assited coding.

I realized that my projects suffered from architectural drifts and that I needed to delegate the "typing" but keep a tight grip on the "thinking". This kit is the result of that investigation: A way to leverage the massive efficiency-boost of AI without sacrificing the quality standards of professional engineering.

It is opinionated, meaningful, and, I think, most likely a bit anti-hype.

Where to start​

  • Quickstart: If you just want to see it work.
  • The Rules: Read the brain of the system (.cursorrules).
  • The Workflow: See how an AI Feature Cycle works properly.
To put this into perspective

This kit is comprehensive, but you don't need to use everything. Furthermore, the system does not enforce anything automatically (yet). It requires the user's acceptance to follow the suggested steps by the contextFirst assistant.

The "Zero to Hero" Path:

  1. Essential (Start here)

    • docs/project-brief.md (What are we building?)
    • .cursorrules (The System Enforcer)
    • docs/active-feature.md (The execution engine)

  2. Recommended (For complex apps)

    • docs/architecture/*.md (ADRs, State, Domain Model)
    • docs/lessons-learned.md (Project Memory)

  3. Optional (For visual products)

    • docs/specs/*.md (UI/UX definitions)

Ready to start?​

Go to Getting Started to set up your repository in 2 minutes. The contextFirst system will guide you from there on.

This is an Invitation (Not a Dogma)​

I am not a "Guru". I am simply an engineer who got tired of debugging AI hallucinations.

This system represents my personal "Operating System" for surviving the AI age. It works for me. It gives me peace of mind that my codebase won't collapse under its own weight after three sprints.

But development is a personal craft.

  • Take what works.
  • Ignore what doesn't.
  • Improve it.

For sure, "Vibe coding" is fun for weekend hacks. But if you are building something that needs to survive longer than 4 weeks (and generate revenue), you need a system. This is mine. I hope it helps you build yours.

License and Usage​

Use freely, adapt consciously, and improve deliberately. Tipp: If you change the rules, do so explicitly and document why.

Got questions, suggestions, or just want to connect?

Contact Me

📚 Quick Navigation​