AI Vibe Coder

Let's be clear up front: this is not about pretty landing pages or front-end mockups. I build full enterprise-grade products — real backends, data layers, integrations, auth, infrastructure, the hard stuff that has to actually work under load and not break. Here's what's possible with the right approach: I recently built a product that a team of 53 engineers spent 3 years building — except theirs was buggy, slow, and constantly breaking. I built a superior, production-grade version myself in one month. That's 159 engineer-months of work, done in 1. I do it by building on my own stack — assembled from open-source AI infrastructure, agent runtimes, and tooling I've wired together — orchestrating AI agents and the best open components instead of hand-typing every line. I need someone who already works this way — ideally faster and sharper than me — who can plug into my stack and build serious systems at this velocity. If you only do front-end vibe pages, this isn't for you. If you can architect and ship complete enterprise systems — fast — using agents, pipelines, and open-source building blocks, keep reading. What You'll Do - Architect and ship enterprise-grade products end to end: backends, databases, APIs, integrations, auth, infrastructure — not just UI. - Build in a fast-moving codebase using AI-native development and a self-hosted, open-source–based agent stack. - Integrate and adapt open-source AI infrastructure — agent runtimes, LLM observability, memory/RAG systems, local and self-hosted model tooling. - Take loosely-specified goals and drive them to working, verified, production-ready code — design, implement, test, iterate — with minimal hand-holding. - Replace what would normally take a team — and do it cleaner: solid architecture, clean commits, real tests, no silent technical debt. - Improve the stack and workflow itself — better orchestration, better automation, better leverage. You Must Have - Proven, extreme-velocity AI-assisted development on real systems — not toy apps or templates. Show me what you've shipped and how fast. I'm not impressed by "10x" — I'm looking for people who collapse team-years into days on production-grade software. - Real engineering depth. System design, data modeling, APIs, state management, performance, security — you understand what makes enterprise software hold up, not just look good. - Strong fundamentals. You can read and debug code you didn't write. AI accelerates you; it doesn't replace your judgment. - Comfort assembling open-source components: self-hosting services, wiring APIs together, making independent tools work as one system. - Full-stack fluency: TypeScript/Node, Python, Git, APIs, databases, deployment. - Agent/LLM literacy: tool use, prompt engineering, RAG, multi-agent patterns, model selection (including open-weight and local models). - Bias to ship. You verify your work (tests, actually running the app) before claiming it's done. Speed and reliability — the incumbents were fast at neither. Bonus Points - Experience self-hosting agent frameworks, LLM observability, vector stores, or local model inference. - You've built your own automations, agent pipelines, or custom tooling on top of open-source. - You've shipped or maintained software at real scale and can speak to what broke and why. How to Apply (filters out the noise) Don't send a generic proposal. In your first message: 1. Link to the most complex, real system you've built fast — repo, demo, or video. Front-end-only portfolios will be passed over. 2. Tell me your exact stack/workflow: which open-source tools you use and how you orchestrate them. 3. One sentence: the most ambitious thing you've built solo, and how long it took. Applications without these three things get ignored. 1. Core Engineering (non-negotiable) These are the fundamentals that separate "ships real systems" from "ships demos." - System architecture & design — service boundaries, data flow, choosing the right pattern for the job, designing for change. - Backend engineering — APIs (REST/GraphQL), business logic, background jobs, queues, caching. - Data layer — relational (Postgres) + NoSQL, schema/data modeling, migrations, query performance, transactions. - Auth & security — authentication/authorization, secrets management, input validation, common vuln classes (the stuff enterprise buyers audit for). - Full-stack fluency — TypeScript/Node and Python at minimum; able to do front-end when needed but not only front-end. - Testing & verification — unit/integration/e2e, actually running the app before declaring done. - Git & version control discipline — clean commits, branching, code review hygiene. 2. AI-Native Development (the differentiator) This is what makes the velocity possible. Without this, they're just a normal good engineer. - AI-orchestrated coding workflow — power user of agentic coding, not a casual prompter; knows how to drive an agent to a correct result and catch when it's wrong. - Prompt engineering — structured prompts, context management, getting reliable output from models. - Multi-agent orchestration — chaining/parallelizing agents, pipelines, task decomposition, verification loops. - Tool use / function calling — wiring models to real tools and APIs. - RAG & memory systems — vector stores, embeddings, retrieval design, knowledge/context management. - Model selection & tradeoffs — knowing which model for which task, including open-weight and local models. 3. Infrastructure & Open-Source Integration (your stack-specific need) This is the part that's unique to how you work — assembling a stack rather than renting one. - Self-hosting & DevOps — Docker, deployment, environment config, running services yourself. - Open-source integration — reading unfamiliar codebases, adapting/forking OSS, making independent tools work as one system. - Agent runtimes — experience with self-hosted agent frameworks. - LLM observability — tracing, logging, dashboards (e.g. self-hosted observability tooling). - Local model inference — running open-weight models locally, quantization, serving. - API/service glue — connecting third-party and internal services reliably. 4. Judgment & Working Style (what makes it enterprise-grade and not a mess) Easy to overlook, but this is what separates "fast and breaks everything" from your actual result. - Debugging code they didn't write — including AI-generated code; can find the silent failure. - Knowing when AI is wrong — healthy skepticism, verification instinct, doesn't ship hallucinated logic. - Bias to ship + bias to correctness simultaneously — speed without leaving technical debt landmines. - Working from loose specs — turns vague intent into the right thing without hand-holding. - Self-direction — operates independently at high velocity; doesn't need to be managed task-by-task.