Developers adapt AI coding agents with skills, deterministic checks, and human review

We use Anthropic's Claude to help build and maintain this site — it's the AI assistant answering questions in the corner of this page right now, and it's also been in the room for the actual engineering work: bug fixes, new features, content, even internal tooling. That gives us a real answer to a question prospects ask a lot: does AI actually hold up on production work, or is it a demo trick? Here are three specific things we learned, not the generic "AI changes everything" take. 1. AI is only as good as its willingness to verify, not guess A mobile layout bug came in: a section on the homepage was crowding the edge of the screen on phones. The obvious move is to read the CSS and reason about what should be wrong. That's also how you miss the real bug. The actual cause was a legacy stylesheet with five overlapping @media breakpoints that aren't mutually exclusive — a fix scoped to one breakpoint doesn't override a conflicting rule at a wider breakpoint that's still in effect at the same screen width. The only way to catch that reliably was live browser inspection at the actual viewport size — checking computed styles, not just reading the source and assuming. We treat that as a hard rule now: verify UI fixes in a real browser before calling them done, every time, no exceptions for "obvious" fixes. 2. The failure modes of the tool matter as much as its capabilities Generating a branded social media graphic sounds simple — a photo, a logo, some text. Doing it programmatically (rather than by hand in a design tool) means moving image data through several systems: downloading a photo, encoding it, handing it to a script, exporting the result. One early attempt corrupted an image silently — no error, just a slightly-wrong file that "worked" until you checked the byte count against the source. The fix wasn't a smarter AI, it was a different process: move binary data file-to-file through the shell instead of retyping it, and verify file sizes instead of trusting that "no error" means "correct." That's an engineering discipline problem, not a model-quality problem, and it's the kind of thing you only learn by actually shipping things, not by reading about AI coding in the abstract. 3. Genuinely obscure technical depth is where it gets interesting Building a branded PowerPoint template meant understanding the difference between a .potx template and a regular .pptx file — which, it turns out, has nothing to do with the file extension. It's a single content-type declaration buried in the file's internal XML (presentationml.template.main+xml vs presentationml.presentation.main+xml). Get that wrong and PowerPoint silently treats your template as a regular presentation. That's not a "write me a poem" task. It's the kind of specific, unglamorous technical detail that separates AI-assisted work that actually ships from AI-assisted work that looks good in a demo and falls apart on contact with a real file format. The honest takeaway None of this replaces engineering judgment — it accelerates it, if the process around it is disciplined: verify instead of assume, know your tools' actual failure modes, and don't shy away from the unglamorous technical details. That's the same standard we hold any senior engineer to, human or AI-assisted. See how we evaluate and apply Claude and other AI platforms across client engagements, or read what we're building it on.

The prompt engineering trap Most developers start with a single prompt. You tell an LLM to "write a technical guide about X," you get a generic result, and then you spend an hour manually editing the hallucinations. This is not a workflow. It is just a faster way to get a bad first draft. When I first tried to automate my technical blog, I thought the solution was a longer prompt. I spent days perfecting a 500 word system instruction. It still failed because the LLM cannot verify its own claims in a single pass. It just predicts the next token. To get production-ready content, you need to move from a linear prompt to an agentic loop. This means breaking the task into roles: a researcher, a writer, and a critic. The Architecture of a Content Loop An agentic workflow treats content as a state machine. Instead of one big call, you chain several small, specialized calls that check each other's work. 1. The Research Agent This agent does not write. Its only job is to find facts. Give it access to your codebase or a set of documentation URLs. Ask it to produce a structured JSON object of key technical constraints, API endpoints, and edge cases. If it cannot find a specific fact, it must flag it as "missing" rather than guessing. 2. The Draft Agent This agent takes the JSON from the researcher and turns it into prose. Because the facts are already locked in, the writer cannot hallucinate as easily. The goal here is structure and flow, not accuracy. Accuracy was handled in the previous step. 3. The Critic Agent (The Most Important Part) This is where the magic happens. The critic agent is given the original research data and the draft. Its prompt is simple: "Find three things in this draft that contradict the research or sound like marketing fluff." If the critic finds errors, the draft is sent back to the writer with the feedback. This loop continues until the critic gives a thumbs up. This is a self-correcting system. Implementing this with Code You do not need a heavy framework to start. A few Python scripts or a Node.js loop will work. The key is the data hand-off. Research Phase: Output a Markdown list of facts. Draft Phase: Use those facts as context blocks. Review Phase: Use a boolean check (Pass/Fail). If Fail, loop back to Draft. One common mistake is letting the agent decide when it is finished. Agents are too polite. They will say "This looks great!" just to end the task. You need to force the critic to be pedantic. Tell it that its only reward is finding mistakes. Scaling to GEO (Generative Engine Optimization) We are moving from a world of SEO to GEO. People are not just clicking links; they are asking Perplexity or ChatGPT for a summary of a solution. These engines prioritize cited, factual, and structured data. To optimize for this, your agentic loop should specifically target "cite-able" moments. Instead of saying "Our API is fast," the agent should be forced to say "Our API responds in 40ms as shown in the benchmark tests." When you provide concrete data and clear citations, LLMs are more likely to pick up your content as a primary source for their users. This is how you win in the age of AI search. Concrete Takeaway Stop trying to find the perfect prompt. Instead, build a pipeline: Research -> Draft -> Critic -> Refine. By separating the factual research from the creative writing, you eliminate 80% of hallucinations and create content that actually helps developers. I use Citedy (https://www.citedy.com) to help manage the sourcing and citation side of this process, ensuring the facts stay grounded. Build the loop, not the prompt.

How an alert, ten browser tabs, and a Slack ping actually get resolved when AI is in the loop — and where I still don't trust it. An alert fires. I open Grafana. Then CloudWatch. Then the logs. Then kubectl describe on the pod that's misbehaving. Then GitHub, to see what merged. Then Argo CD, to see what actually rolled out. Ten tabs in, trying to hold six timelines in my head at once, someone drops into the channel: Do we know what happened yet? That moment is the real job. Not the syntax. Not remembering the exact kubectl flag. The job is correlating scattered signals fast enough to form a hypothesis worth testing. That's the part where AI has changed how I work. It didn't take the troubleshooting away from me. I'm still doing all of it. It just shortened the gap between "something is wrong" and "this is probably where I should look." I don't use AI as a replacement for understanding Kubernetes, AWS, Terraform, Linux, networking, databases, or CI/CD. I use it as another tool in the workflow, one that helps me get from a problem to a testable hypothesis faster. My AI usage today broadly splits across three areas: ChatGPT — communication, research, reasoning, and technical analysis Claude and Claude Code — coding, Kubernetes, scripts, configurations, and troubleshooting AWS DevOps Agent — AWS infrastructure investigation, resource analysis, troubleshooting, and optimization Each tool has a slightly different role. The part that actually matters isn't having access to AI. It's knowing where it's useful, what context to give it, and when its output needs to be challenged. None of them makes a production decision for me. One habit before I get into the tools: I'm careful about what I paste into any of them. Config with real hostnames, account IDs, or anything secret-shaped stays out. ChatGPT: the part of DevOps nobody warns you about People underestimate how much of this job is communication. I'll finish a technical investigation and then have to explain it — to a developer, a manager, a vendor, or the wider team — without either dumping raw metrics on someone who doesn't need them or oversimplifying to the point of being wrong. A recent example: I was looking at EKS control-plane logging. I'd already done the actual work — figured out that api, audit, and authenticator logs were adding up to roughly 20–25 GB of ingestion per cluster per month, that ingestion was the real cost driver rather than storage, and that the sensible levers were trimming which log types we actually needed and dropping retention from 90 days to 30. That investigation was mine. What I didn't want to spend twenty minutes on was rewriting the summary three times until it read cleanly for a Slack thread. So I hand ChatGPT the findings and let it tighten the explanation. It isn't helping with the investigation. It's helping with the communication overhead after the investigation. The second way I use it is more interesting: as a second pair of eyes on my own reasoning. Say I've got a c7i.2xlarge sitting mostly idle and I'm thinking of dropping it to c7i.xlarge. The weak version of the question is "should I downsize this?" — because it just tells me what I already decided. The version I actually get value from is: What am I missing before I make this change? And it'll nudge me toward network throughput, EBS bandwidth, short-lived peaks that a 30-day average hides, workload patterns, rollback path. Half of those I'd check anyway. But every so often it names the one I would've skipped, and that's the whole point. I stopped asking AI to make the call and started asking it to find the hole in mine. Claude and Claude Code: reducing the search space I use Claude for the code-shaped work — Kubernetes manifests, Bash and Python scripts, CI/CD config. That part's useful but not that interesting; generating a Deployment YAML was never the hard part. Claude Code is where it gets useful, because a Kubernetes problem almost never lives in one file. The behavior I'm chasing is usually smeared across Helm templates, values.yaml, values-prod.yaml, a ConfigMap, a Secret, a GitHub Actions workflow, and whatever Argo CD is actually syncing. Previously I'd grep my way through all of it by hand, holding the thread in my head the whole time. Now I can ask, against the real repo: Find where DATABASE_HOST is defined and explain how it reaches the production Deployment. Or: Compare dev and prod and show me anything that affects memory limits or scheduling. Here's a concrete one. A pod keeps restarting. I run the usual: kubectl describe pod <pod> kubectl logs <pod> kubectl logs <pod> --previous kubectl get events And I find: Last State: OOMKilled Exit Code: 137 I already know the direction — this is memory. What used to eat my time wasn't forming that hypothesis; it was the file-hopping to test it. Where's the current limit set? Is a prod override quietly bumping it down? Did a recent change touch the Helm values? Claude Code walks that trail with me instead of me opening eight files to reconstruct it. It's also confidently wrong sometimes. Once it pointed me at a limit in values.yaml and told me that was the effective value in prod — except Argo CD was syncing that service from a different repo, so the file it was reading never applied. The answer looked right. It just didn't know about the source it couldn't see. That's exactly why the output is a lead, not a verdict: it reduces the search space, and then I confirm what actually applies. AWS DevOps Agent: correlating telemetry I'd otherwise eyeball This is the most infrastructure-facing part of how I work. Worth being precise here, because it's a capable product and it's easy to undersell. AWS DevOps Agent can go a long way on its own: it investigates incidents autonomously, correlates telemetry with code and deployment data, and produces root-cause analysis and mitigation plans without me driving each step. I read those as a strong lead, not a verdict. The part I lean on most is the correlation, because that's where it saves me the tab-juggling. The root-cause call and anything that touches production, I still confirm and own myself. AWS already collects an enormous amount of operational data. Finding the graphs was never the problem. The problem is figuring out what changed at the same time as the thing that's on fire. RDS is the clearest example. A CPU spike shows up, and normally I'd be pulling up CPUUtilization, DatabaseConnections, FreeableMemory, read/write IOPS, latency, DiskQueueDepth, Performance Insights, and the RDS events feed — one tab at a time. Say the picture looks like this: 10:00 CPU: 20% Connections: 100 10:05 CPU: 85% Connections: 450 10:10 CPU: 95% Connections: 700 The useful observation isn't "CPU hit 95%." Anyone can read that off a graph. The useful observation is that CPU and connections climbed together, and that turns a symptom into a hypothesis. Maybe replicas scaled up. Maybe connection pooling fell over. Maybe a scheduled job kicked in, or queries got slower, or a retry loop started hammering the database. Correlation isn't proof. I still have to confirm which of those it actually was — and this is where Performance Insights earns its place: top SQL by load told me the time was going into a single unindexed query, which ruled out the retry-loop and pooling theories fast. But having the correlation surfaced for me is the difference between starting an investigation and starting it fifteen minutes late. The same correlation habit feeds straight into cost work. Picture a c7i.2xlarge running at ~5% average CPU, ~15% peak, memory under 15%. The lazy move is to downsize on CPU alone. Instead I want CPU, memory, network, EBS/disk, and the peak-workload periods considered together, because low CPU with high memory is a completely different story. One catch that's easy to miss: halving the instance size also halves the network and EBS bandwidth ceilings, so that 15% peak has to be re-checked against the smaller instance's limits, not the current one's. When the signals genuinely agree that c7i.2xlarge → c7i.xlarge is safe, and I've validated it, AI has directly helped me cut spend while keeping real headroom. That's more honest than saying "AI helps with cost optimization." It helped me confidently run the workload smaller. The thing all three have in common Strip away the tools and here's what actually changed. Before: Alert → metrics → logs → docs → repo search → config comparison → hypothesis Now: Alert → collect evidence → AI helps correlate/search → hypothesis → validate → fix The steps didn't disappear. The evidence still has to be collected, the hypothesis still has to be validated, the fix is still mine to ship. What compressed is the messy middle: the correlating, the searching, the file-hopping. Where the human stays in the loop I don't hand production to any of this. If a right-sizing analysis says an instance can shrink, I don't just run terraform apply. If Claude generates a manifest, I read every line of it. If the AWS agent points at a root cause, I still go confirm the metrics say what it thinks they say. My loop is boring on purpose: AI suggestion → understand it → validate it → make the change → monitor → roll back if needed The trap is easy to fall into: create Kubernetes Deployment, copy the YAML, ship it. But if you can't explain your own resources.requests, your probes, or your affinity rules, AI just made you faster at deploying things you don't understand. That's more dangerous, not less. AI makes syntax, searching, and retrieval cheap. If the syntax is cheap now, the judgment about whether to run it is the part that's actually worth paying an engineer for. What moved is how long I spend getting from "something is wrong" to "this is probably where I should look." That gap used to be most of the incident. Now it's a smaller part of it, and I'd rather spend my time on the part that actually needs an engineer. One question for the DevOps, SRE, cloud, and platform folks: where has AI actually created more work for you than it saved — a wrong root cause you chased, a confident answer that was subtly off, a place you still don't trust it? (And if you've got a genuine win, I'll take that too.)

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. Let me guess. You opened Claude Code, typed "build me a modern landing page," hit enter, and got back something that technically works but somehow looks like every other site you have ever scrolled. Purple to blue gradients. Inter for everything. Little rounded icon tiles floating above every heading. A hero section that could belong to literally any SaaS on earth. Congratulations, you have been served a fresh bowl of AI slop. I have been fighting this exact fight for a while now, and I want to walk you through how I actually beat it. Not with one magic prompt, and definitely not with a 10,000 line DESIGN.md you copied from a thread. Just three moves, a couple of tools, and a way of working that stops leaving your output to the gods of the one shot. First, why does slop even happen? Here is the uncomfortable truth, and it is worth sitting with for a second. The problem with slop is not technical. The models are not bad at writing CSS. They are frankly great at it. The problem is that the output is generic, and generic is a moving target. If the models got ten times better tomorrow, they would just raise the bar on what counts as basic. The floor moves up, the slop moves with it. Why? Because a model trained on the public internet learns the statistical center of the public internet, and the center of the design internet in 2026 is Tailwind templates, Vercel starters, and other AI generated landing pages. Ask for "modern" and you get the mathematical average of every landing page ever shipped. That average is the slop. So the fix is not a better model. The fix is you. Specifically, your taste. And that is where a lot of us cope instead of cook. Yeah. That is the cope. The rest of this post is about doing the opposite. Here is the whole game on one screen before we dig in: Step 1: Cultivate some taste (you cannot inject what you do not have) You have heard "AI has no taste" a hundred times. Fine. But the sneaky corollary nobody says out loud is that you need taste to hand over, and most of us have not deliberately built any. We just vibe. So step one is boring and unglamorous and completely non negotiable: go collect stuff you like. Become a magpie. Open Dribbble, search "web design," sort by popular, and start screenshotting the hero pages that make you feel something. Do the same on Pinterest. Then, and this is my personal favorite, go to Twitter slash X, where a genuinely absurd amount of the best UI work gets posted before it lands anywhere else. Save screenshots. Save links to live sites too, since a real page tells the model way more than a flat image. Now, you could just let those screenshots rot in a folder called inspo_FINAL_v3. Or you could do the fun version and have Claude Code spin up a tiny inspiration library web app for you. Mine groups everything by design style, names the aesthetic in actual design vocabulary, and gives me keywords for each piece. Click a screenshot and I can copy an image prompt (for generating a matching hero background later) or copy a full brief (for generating the whole page). It turns a pile of pretty pictures into a reusable palette of your taste. The point of this step is not to copy anyone. It is to give your future self a base to point at, so you are never starting from a blank prompt and an average result. You are starting from a direction you already know you like. Step 2: Arm Claude Code with tools it does not ship with Out of the box, Claude Code is a strong developer with the visual judgment of a coin flip. So we hand it better eyes and better hands. Three categories are enough. A real design skill The default Anthropic frontend-design skill was a fine start, but at this point it kind of produces the slop it was meant to prevent. The one I reach for now is Impeccable, an open source Claude Code skill by Paul Bakaus. Instead of vaguely begging the model to "not look AI generated" (which never works), it does something clever: it names the specific slop patterns and tells the model to avoid them. It ships as one skill with a stack of commands you invoke like slash commands. A few that I use constantly: /critique for an honest UX review of hierarchy and clarity /bolder to push a safe, boring design toward actual impact /quieter to pull an over caffeinated design back down /polish for a final alignment and spacing pass before shipping Under the hood it hunts slop across seven areas: typography, color, spatial design, responsiveness, interaction, motion, and UX writing. There is even a Chrome extension that highlights slop patterns on a live site, which is a little bit rude and extremely useful. The before and after examples in the docs sell it better than I can. If Impeccable is not your flavor, there are other "taste" style skills in the same spirit floating around GitHub, and they work on the same principle. An image and video MCP Claude Code cannot draw. It cannot generate that moody cinematic mountain range you want behind your hero text. So give it the ability with the Higgsfield MCP, which basically hands your agent a backstage pass to 30 plus image and video models through a single connection. You describe the hero image, it generates it, drops it into the section, done. No tab hopping to five other tools. A component registry For the smaller stuff, buttons, cards, pricing sections, pagination (when was the last time you thought hard about pagination?), I browse 21st.dev. It is an open registry where each component ships with a "copy prompt" button. Paste that into Claude Code and it rebuilds the component inside your codebase, wired to your stack. Think of it as step one's taste hunting, but zoomed all the way in to the component level. One warning before you go tool shopping Here is the trap, and I have fallen in it more than once. It is very easy to convince yourself you are one skill away from all your design problems being solved. You are not. You will find flashy skills that build gorgeous sites. The catch is they tend to be narrow and extremely prescriptive, so they hand you exactly one kind of output every time. That is not taste, that is a template with extra steps. I like Impeccable and Higgsfield precisely because they are flexible. The downside of flexible is that they will not magically produce greatness. That still depends on your prompting and your taste. Which is the point. Step 3: Build in loops, not in one shots This is the mindset shift that changed everything for me, so read it twice: stop trying to one shot. The one shot is a lottery ticket. You type "make it premium," hit enter, and pray. Sometimes you win. Usually you get slop with a slightly nicer font. Instead, cast a very wide net up front, then narrow down. Here is the actual sequence I run: Let me make that concrete. Say I am building a landing page for a made up AI analytics startup called Kestrel, and the goal is to get people to book a demo. First, five versions in five styles, all at once. Not one, five. If you built that inspiration library from step one, you can just tell Claude Code to look at it, pull five aesthetic families, and build a page in each. Seeing them side by side on one screen makes it obvious which direction has legs, in a way that squinting at a terminal one attempt at a time never does. Say I land on a "vast quiet" minimalist look with a big cinematic image behind the hero. Then, three variations of that one direction. Same aesthetic, different body layouts. Maybe one is super vertical and minimal, one is a "ledger" style with an index that scrolls alongside you, one frames each section with edges. I pick the ledger, because that scrolling index is genuinely cool. Then I nail the hero image before fussing with anything else. I fire up the Higgsfield MCP, ask for four 2K options that fit the quiet aesthetic, and look at them in the actual hero slot. Too black and white? Ask for variations with a splash of color. That gentle golden "alpenglow" one? Sold. Then transitions and weight. I ask for the hero to fade into the body instead of hard cutting, and for elements to load in with a bit of heft so the whole thing feels premium rather than snappy and cheap. Notice what is happening. At every stage I am seeing options and choosing, not blindly trusting a single generation. That is the whole trick. The four things worth putting in your prompt You do not need a giant design doc. When those get too specific, they just produce the same thing every time, which is the slop problem wearing a fancier coat. I pass four things, loosely: Aesthetic. The general family of design you are going for. Reference image. This is where your taste library earns its keep. Drop a screenshot, or better, an actual URL of a site you like. You are matching a feeling, not copying content. Intent. What is this and why does it exist? SaaS product? Event page? Who is the audience and what do you want them to do, read, click, or fill out? Guardrails. The always and the never. This is your anti slop clause. "Never use purple gradients. Never use Inter. No 3D SaaS blobs." The secret weapon: a live tweak bar Even after all that, the page felt almost right but a touch too minimal. Instead of guessing with more "make it pop" prompts, I asked Claude Code to add a live tweak bar to the dev server, the kind of panel you see inside Claude Design. Font family, font size, accent color, motion, reveal distance, anything where a design decision lives. Now I iterate by eye. I flip through fonts in real time instead of asking for ten rebuilt pages and comparing them like a lunatic. Being able to see differences instantly is the thing that finally gets you to something you actually like. And do not forget: references are not just for the hero. Feed the model URLs and screenshots for how you want the body laid out too, since Claude Code can look at a live page and apply its structure. Wrapping up None of this is a rulebook. Do not follow it to the letter, because the second something becomes a rigid formula, it starts producing its own flavor of slop. The point is a flexible workflow you can bend to any project: Cultivate taste so you have something to hand over. Arm your agent with a design skill, an image MCP, and a component registry. Then build in loops, wide net first, tweak by eye last, so you are never at the mercy of a single roll of the dice. The moat was never the toolbox. It was always your taste. Go build something that looks like you, and leave the purple gradients where they belong. If you try this, I would love to see what you ship. Drop a link in the comments and let us compare notes. AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs — without telling you. You often find out in production. git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free. Any feedback or contributors are welcome! It's online, source-available, and ready for anyone to use. ⭐ Star it on GitHub: HexmosTech / git-lrc Free, Micro AI Code Reviews That Run on Git Commit | 🇩🇰 Dansk | 🇪🇸 Español | 🇮🇷 Farsi | 🇫🇮 Suomi | 🇯🇵 日本語 | 🇳🇴 Norsk | 🇵🇹 Português | 🇷🇺 Русский | 🇦🇱 Shqip | 🇨🇳 中文 | 🇮🇳 हिन्दी | git-lrc Free, Micro AI Code Reviews That Run on Commit         GenAI today is a race car without brakes. It accelerates fast -- you describe something, and large blocks of code appear instantly. But AI agents silently break things: they remove logic, relax constraints, introduce expensive cloud calls, leak credentials, and change behavior -- without telling you. You often find out in production. git-lrc is your braking system. It hooks into git commit and runs an AI review on every diff before it lands. 60-second setup. Completely free. In short, git-lrc helps Prevent Outages, Breaches, and Technical Debt Before They Happen At a glance: 10 risk categories · 100+ failure patterns tracked · every commit… View on GitHub

Most AI tools only tell you what they're good at. That's how you end up discovering the gaps in production. So here's the other half: where our AI agent still misses, specifically, and what we're doing about each one. What it's genuinely good at Targeted bug-fixing (~85–90%) — given real broken code, it produces a fix that compiles clean and makes the specific change. Simple full-stack builds — it scaffolds working SPAs reliably. Prompt → full-stack app → live deploy with a real database — validated end to end. Where it still misses From our own correctness-gated evals, the honest gaps: Complex full-stack scaffolding. On a notes app with auth, it built the database schema but missed declaring the bcrypt / jsonwebtoken dependencies — the kind of gap that compiles in isolation but breaks the build. Run-to-run consistency. A landing-page fixture's dev-server check passed on one run and failed on another. Non-determinism is real, and we measure it instead of hiding it. Small correctness slips. Using React.Fragment without importing it; a to-do app that skipped localStorage persistence. Individually minor — exactly the sort of thing you'd want to catch in a diff review, not in production. Read-only tasks. On a task that only asked it to find and report something, it wrote files instead of answering. Knowing when not to act is its own skill. What we do about it Every genuine failure feeds a closed self-improvement loop: the run is analyzed, a prompt change is proposed, and the candidate is validated against the same correctness gate — with a holdout set guarding against regressions — before anything reaches production. Some of the misses above already have fixes in flight; some don't yet. We publish both states. Why publish this at all Because you're going to hit these limits either way — the only question is whether you find out from us now or from a broken build later. It's also why NoCoder puts diff review at the center: the agent isn't perfect, so you stay in the loop. Every change is a per-file diff you approve before it applies. The short version: Our agent is strong at bug-fixing (~85–90%) and simple full-stack builds, and weaker on complex scaffolding, consistency, and a few specific tasks (missed auth deps, a skipped localStorage step, a Fragment import, a read-only find task). We fix what we can via a validated self-improvement loop and publish the rest. See how we benchmark or try NoCoder free. This post originally appeared on the NoCoder blog. NoCoder is an AI full-stack app builder that shows every change as a diff you approve before it ships — build at AI speed, ship only what you've reviewed. Free to start on free models.

When you're a solo founder and lead architect, your knowledge base is your most valuable asset. Lose the thread on why a decision was made, and you spend hours — sometimes days — reconstructing context that you already figured out once. I want to share the exact setup I use at NEXT4I to turn a folder of Markdown files into a fully searchable, version-controlled, AI-readable knowledge system. No proprietary SaaS, no vendor lock-in, no custom integration work. This is the Key Highlight of this post: a genuinely useful, generic pattern you can apply to your own projects today. The NEXT4I-specific business logic stays abstracted (per our security rules), but the pattern itself is 100% reusable. 1. The Architecture: Three Layers, Zero Magic ┌─────────────────────────────────────────┐ │ AI Agent (VS Code) │ │ Reads, Searches, Summarizes, Drafts │ └──────────────────┬──────────────────────┘ │ reads plain .md files ┌──────────────────▼──────────────────────┐ │ Git-tracked Obsidian Vault │ │ ├── Idea/ (brainstorms) │ │ ├── Infrastructure/ (architecture docs)│ │ ├── Platform/ (product specs) │ │ ├── Script/ (automation) │ │ └── Skill/ (reusable limits) │ └──────────────────┬──────────────────────┘ │ committed & pushed ┌──────────────────▼──────────────────────┐ │ GitHub (remote backup) │ └─────────────────────────────────────────┘ Layer 1 — The Vault (Obsidian): A folder of interconnected .md files. The key insight is that Obsidian uses plain Markdown with [[wiki-links]] for connections — no database, no proprietary format. Layer 2 — Version Control (Git): Every vault is a git repo. Every change to any document has a commit message, a timestamp, and a diff. You can git log --oneline -- Idea/ to see the evolution of a concept. Layer 3 — AI Agent (VS Code Extension): Because the vault is just a file tree of .md files, any AI coding agent that can read a codebase can also read your knowledge base. Point the agent at the vault folder, and it has full context. 2. The Setup: Step-by-Step Step 1: Create the Vault mkdir next4i-knowledge cd next4i-knowledge mkdir Idea Infrastructure Platform Script Skill git init Open this folder in Obsidian: Open folder as vault. Step 2: Link Everything Inside a note, link to another note with [[Note Name]]. Obsidian auto-suggests as you type. Over time, this builds a graph you can visualize with Cmd/Ctrl + G. Pro tip: Create a _INDEX.md in each folder that links to the most important notes. This becomes a human-readable table of contents AND a search anchor for the AI. Step 3: Add Git Discipline git add -A && git commit -m "infra: initial sharding strategy decision" git remote add origin git@github.com:your-org/knowledge-vault.git git push -u origin main Treat commit messages like code. Use prefixes: idea:, infra:, platform:, script:, skill:. This makes git log --oneline --grep="infra:" instantly useful. Step 4: Open in VS Code and Activate the AI code /path/to/vault With an AI agent extension active (Copilot, Cline, Cody, etc.), try prompts like: "Summarize the key architectural decisions in the Infrastructure folder." "Find any contradiction between documents in /Platform/ and /Infrastructure/." "Draft a new document in /Idea/ based on the sharding notes in /Infrastructure/." The agent reads the files as context, just like it would for code. 3. The Design Pattern: Folder-Convention-as-API Here's the key pattern: your folder structure IS your API. By keeping a consistent vault structure, both humans and AI know where to look: Folder Contains AI Use Case Idea/ Raw, unstructured thinking Generate summaries, find related concepts Infrastructure/ System topology, deployment, config Validate consistency, trace dependencies Platform/ Feature specs, user flows Draft task tickets, check requirement coverage Script/ Automation, one-liners Explain what a script does, suggest improvements Skill/ Reusable patterns, checklists Retrieve relevant patterns for new tasks This is essentially a convention-based RAG (Retrieval-Augmented Generation) setup without any vector database, embedding pipeline, or chunking strategy. The "chunking" is the natural boundary of each .md file. The "retrieval" is the AI agent's file-reading capability. 4. Why This Beats a Wiki Wiki / Confluence This Setup (Obsidian + Git) Vendor lock-in Plain .md files, portable anywhere Search is siloed within the tool VS Code AI searches across the whole vault No version control (or poor built-in) Full version control (git blame, git diff, git log) Hard to automate Scriptable — grep, sed, and AI prompts all work AI needs API integration AI reads files natively, zero setup required 5. What I Learned The biggest surprise: The AI agent became better at finding connections in my own notes than I was. It doesn't have recency bias. It doesn't forget what I wrote 8 months ago. It reads everything with equal attention. The biggest lesson: AI-native doesn't mean "add an AI button." It means design your systems — including your thinking systems — so that AI can participate as a first-class citizen without special plumbing. I'm building NEXT4I as an AI-native ecosystem from the ground up. If you're interested in following a solo founder's engineering journey — or want early access — join here: Subscribe NEXT4I or want early access — join here