⚡ Core Paradigm · Software Development Evolution

Intent Engineering & Vibe Coding

Intent Engineering is the fundamental evolution of software development from manual syntax typing into vibe coding through high-level human intent. Instead of spending hours writing boilerplate code, debugging CSS quirks, configuring reverse proxies, and wrangling deployment scripts, you express in plain, natural prompts what you want to build. An agentic LLM pairing system—specifically Google DeepMind's Antigravity CLI backed by Gemini Code Assistant—interprets that intent, inspects codebase context, writes the files, runs tests, and executes the changes directly.

The ultimate proof of this paradigm is the website you are reading right now (gert.haegdorens.com). It was built from scratch and continuously expanded—from its FastAPI backend and responsive design tokens to complex interactive hubs and automated CI/CD pipelines—in just hours. The single most time-consuming part was not writing code; it was curating, researching, and authoring the authentic content itself.

"In Intent Engineering, the developer is no longer a human typewriter translating logic into syntax. You become the Chief Architect, Director, and Reviewer. You define the intent, set the guardrails, and keep human judgment in the middle while autonomous agents do the heavy lifting."

From Manual Syntax to Vibe Coding

For decades, learning software engineering meant mastering hundreds of esoteric language syntaxes, frameworks, and command-line flags. Intent engineering changes the locus of power:

🎯

Express Pure Intent

You converse directly with your environment in natural language. You state the architectural outcome: "Add authentic Belgian food photography, wrap text in two columns beside the image, contain the container box, and link the museums."

🤖

Agentic Execution

The Antigravity CLI doesn't just output snippets of code for you to copy-paste. It reads your codebase, searches files, executes terminal commands, performs diffs, runs quality linters, and verifies the solution autonomously.

🧠

Human-in-the-Middle

The AI never tells you what to do. You stay in creative flow ("the vibe"), evaluating UX, validating architecture, and refining taste while the machine eliminates 80% of mundane implementation friction.

The Enablement Architecture: The Home Lab Stack

Intent Engineering does not require expensive enterprise cloud tiers or complex SaaS subscriptions. My entire development and deployment pipeline runs seamlessly on a self-hosted home lab setup enabled by eight key components:

1. Ubuntu Server (The Robust Foundation)

OS Layer

A dedicated, quiet, power-efficient Linux home server running Ubuntu Server 24/7. It provides native high-speed file storage, low-latency execution, hardware virtualization, and complete sovereignty over data and credentials without recurring cloud hosting fees.

2. Docker Engine (Isolated Containerization)

Virtualization

Every tool, web application, and background service runs inside isolated, lightweight Docker containers. Applications never pollute the host operating system, environments are completely reproducible, and services can be upgraded or rolled back instantaneously.

3. code-server (Browser-Based Universal IDE)

Developer Workspace

Running code-server inside Docker gives a complete, full-featured VS Code environment accessible securely via any web browser on any machine—MacBook, desktop workstation, Chromebook, or iPad. Your workspace, persistent terminals, and open files remain active and synchronized wherever you go.

4. Antigravity CLI & Gemini Code Assistant ($20/mo)

AI Pairing Engine

The engine of Intent Engineering. Running inside the code-server terminal, Google DeepMind's Antigravity CLI connects to Gemini Code Assistant through a standard Google AI subscription (~$20/month). It acts as an autonomous senior pair programmer equipped with tool capabilities: reading directories, modifying files with precision diffs, running terminal commands, and verifying output.

5. Self-Hosted GitLab & GitLab Runner (CI/CD Pipeline)

Automated DevOps

Code is version-controlled in a private, self-hosted GitLab instance. When a feature is finalized, a single git push origin main triggers a local GitLab Runner that automatically runs multi-stage pipelines: version detection, packaging, Docker container building, and instant deployment without manual intervention.

6. Traefik (Edge Routing & Reverse Proxy)

Reverse Proxy

Traefik serves as the intelligent edge proxy for all Docker workloads. As new containers spin up, Traefik automatically discovers their Docker labels, generates routing rules, manages SSL certificates, and proxies incoming requests to the appropriate internal services.

7. AdGuard Home (Local DNS Rewrites & Privacy)

DNS Layer

AdGuard Home manages DNS for the home network. In addition to network-wide ad blocking and tracker protection, it provides local DNS rewrites so development domains (e.g. *.local.300solutions.com) resolve directly to the server's local IP on the LAN for lightning-fast preview speeds.

8. Cloudflare (Registry, Tunnels & Email Forwarding)

Global Edge

Cloudflare ties the entire architecture together globally:
• Domain Registry & DNS: Authoritative DNS management with global Anycast caching and DDoS defense.
• Cloudflare Tunnel (cloudflared): Exposes the production website to the public internet through a secure outbound connection—without opening any inbound firewall ports on the home router.
• Email Forwarding: Seamlessly routes custom domain email ([email protected]) directly to primary inboxes with zero maintenance overhead.

The End-to-End Workflow Flowchart

From a natural-language prompt in your browser to a deployed production website:

💡
1. Developer Prompt (Intent): Developer types high-level feature requirements in plain language within code-server.
↓
🤖
2. Antigravity CLI + Gemini AI: Reads codebase, analyzes structure, modifies files, runs linters, and verifies the application locally.
↓
🚀
3. GitLab Push & Automated Pipeline: git push origin main triggers GitLab Runner on Ubuntu server to build the updated Docker container.
↓
🌐
4. Traefik & Cloudflare Tunnel: Traefik registers the live container; Cloudflare Tunnel serves it to gert.haegdorens.com globally with zero downtime.

Traditional Development vs. Intent Engineering

Why this paradigm represents an order-of-magnitude leap in solo developer leverage:

Dimension Traditional Development Intent Engineering
Primary Focus Syntax, libraries, boilerplate, typing code System design, user experience, intent & context
Development Velocity Days or weeks per new hub / feature Minutes or hours per complete feature
The Primary Bottleneck Typing speed, compilation errors, documentation lookup Content curation, artistic taste, clear thinking
Software Tooling Cost $100s–$1,000s/mo in proprietary SaaS licenses ~$20/mo (Google AI subscription) + open-source stack
Developer's Role Manual implementer & typist Architect, Director, and Reviewer (Human in the Middle)

Democratizing High-Velocity Engineering

I am actively building a comprehensive tutorial and blueprint of this development environment so anyone can set up their own autonomous coding workstation for roughly $20/month. You don't need venture funding or a 10-person dev team to create world-class software—you just need clarity of intent, a disciplined setup, and an agentic partner.

📍 What I'm Doing /now 🤖 Virtual Assistants Hub 📜 Credentials & Experience 🏠 Home