DEV Community: Abdullah Ahmad

Stop Blaming the LLM: Why Your AI Agents Keep Failing (And How to Fix Them)

Abdullah Ahmad — Sat, 22 Aug 2026 18:08:42 +0000

I was staring at a broken Next.js and Express backend integration late at night, convinced my AI agent had lost its mind. It was supposed to be a straightforward n8n automation pipeline. Yet, every time it ran, it hallucinated non-existent packages and dumped its context halfway through.

My System 1 intuitive reaction flared up immediately: The LLM just isn't smart enough. I sat there, exhausted, ready to rewrite the prompt for the twentieth time.

Engaging System 2
Taking a step back, I forced myself to engage my analytical System 2 brain. I wasn't dealing with a lack of model intelligence; I was dealing with a lack of infrastructure. I was running a massive, powerful AI model with zero guardrails. No persistent memory. No verification. Just dumping a giant Mongoose schema into a prompt and hoping for the best.

I was essentially dropping a Formula 1 engine onto a wooden skateboard and wondering why it crashed at the first turn.

What is Harness Engineering?
I stopped obsessing over prompt engineering and started focusing on Harness Engineering. The model is just the engine; the harness provides the chassis, the steering, and the brakes. Here is how I completely restructured my agentic workflow:

Context Management: Instead of flooding the context window with raw codebase dumps, I implemented targeted retrieval. The agent now only sees the specific files required for the immediate task.

Standardized Tools: I integrated Model Context Protocol (MCP) servers, giving the model bounded, secure ways to execute actions rather than just generating text.

Durable State: If a long-running workflow pauses or fails, the system now checkpoints its progress. It resumes exactly where it left off instead of starting from scratch.

Strict Verification: "Looks good to me" is no longer an acceptable output. The agent is forced to run tests and verify the CLI output before concluding a task.

Learn to Break the System
The results were immediate. The hallucinations stopped, and the agent shifted from a fragile text generator to a dependable developer. Clever models are ultimately useless without reliable systems around them. To achieve true autonomy, you have to learn to break the system you initially trusted and engineer a better one.

What is the biggest challenge you face when trying to keep your automated agents on track during complex tasks?

Architecting the New Operating System: A Guide to Context Engineering

Abdullah Ahmad — Thu, 20 Aug 2026 00:13:44 +0000

Prompt engineering is a conversation; context engineering is system architecture. In the early days of working with Large Language Models (LLMs), optimizing the prompt was enough for simple text generation tasks. But when you are building autonomous systems—like a self-hosted automation server connecting cloud databases, webhooks, and reasoning nodes—prompts alone will not keep track of APIs, past decisions, and strict output constraints.

Think of the LLM as the CPU, and the context window as the RAM. Context engineering is the discipline of treating that memory as a scarce resource, meticulously designing the pipeline that feeds the model the exact facts, instructions, and tools it needs at the precise moment it needs them.

The Four Core Strategies
To shift from vibe-coding a chatbot to architecting a resilient multi-agent system, you must manage what enters and stays in the context window using four primary techniques:

Select: Decide exactly which external sources—like database schemas or specific API documentation—enter the context window to maximize the signal-to-noise ratio.

Compress: Shrink the context payload only after the key facts are successfully structured.

Write: Persist the task state and intermediate decisions outside the active context window so the agent can retrieve them later. Think of this as giving the agent its own local-first markdown vault for networked thought.

Isolate: Separate contexts when domains collide. Instead of forcing one model to do everything, build multi-agent systems where each agent receives a strictly scoped slice of the context.

Navigating the Failure Modes
Stuffing a massive context window with raw JSON logs and unstructured data is a recipe for disaster. When building complex workflows, you must engineer guardrails against these critical failure modes:

Context Poisoning: Hallucinated or incorrect information enters the context and compounds over time because the agent continually reuses it.

Context Distraction: The agent gets bogged down by excessive past history or overly verbose tool outputs, causing it to repeat past behavior rather than reason clearly.

Context Confusion: Providing too many similar tools at once makes selection difficult, distracting the model and degrading the output.

Context Clash: Contradictory rules or data within the prompt leave the agent frozen between conflicting assumptions.

To engineer systems that actually scale, you have to learn to break the system down into isolated, highly governed components.

How are you currently handling memory persistence and state management across your automation workflows?

Why You Are Using AI Wrong (And How a 20-Minute Shortcut Rewired My Workflow)

Abdullah Ahmad — Mon, 17 Aug 2026 01:27:10 +0000

I was this close to dedicating an entire 9-hour block to Google’s Prompt Engineering course. When you are constantly juggling coursework and full-stack projects, time is a luxury. So, when I stumbled upon a 20-minute breakdown that distilled the entire syllabus, I took notes—and it fundamentally changed how I approach large language models.

We often jump straight into building and coding, but if you truly want to learn to break the system, you first have to understand how to communicate with it.

Whether you are automating a Python script, debugging a Next.js component, or bouncing architectural ideas across Claude, Gemini, DeepSeek, or Groq, throwing unstructured questions at an AI is a massive waste of its potential. Treating an LLM like a basic search engine will only give you basic, generic results.

Instead, you need to start treating it like a compiler. Give it the exact right syntax, environment variables, and constraints, and the output becomes limitless.

Here is the exact framework to engineer your conversations.

The 5-Step Blueprint for Perfect Outputs
To get the exact output you need, stop word-vomiting your requests and start structuring them using this five-step formula:

Task (The What & Who) Don't just ask for a script or a summary. Tell the AI exactly what to do and assign it a specific Persona.

Bad: "Write an email about the new schedule."
Good: "Act as a senior project manager. Write a brief, professional email to the dev team about the new sprint schedule."

Context (The Background)
AI lacks intuition. You have to provide the environment. What is the goal? Who is the audience? The more context you provide, the sharper the response.
References (Show, Don't Tell)
AI learns exceptionally well by seeing examples. If you want a specific tone, format, or coding style, paste in a previous example for it to mimic.
Evaluate (The Code Review)
Critically check the output. Did it hallucinate? Did it miss a constraint?
Iterate (The Debugging Phase)
Prompting is rarely one-and-done. Push back. If the output is too generic, ask it to add constraints. If it is too complex, ask it to break the logic down into analogous concepts.

Taking It Further: Prompt Chaining & Custom Agents
The biggest mistake developers make is asking for the entire finished product in one prompt. You wouldn't write an entire application in a single file without testing the individual functions, so don't ask an AI to do it either.

Prompt Chaining: Guide the tool through interconnected steps. First, ask it to generate three database schema options. Then, pick the best one and ask it to write the Mongoose models based only on that chosen schema.

Chain of Thought: Simply tagging "explain your thought process step-by-step" onto your prompt forces the AI to map out its logic before giving you the final answer, significantly reducing errors.

Building Custom Agents: You can configure an LLM to act as a strict expert. Tell it: "Act as a senior systems architect. I will pitch my project structure to you. Ask me follow-up questions one at a time to find vulnerabilities. When I say 'jazz hands', stop and grade my overall architecture."

Stop hoping for the best when you hit Enter. Engineer the context, set the constraints, and start commanding the system.

The End of AI Context Collapse: Giving Claude and Cursor a Permanent Memory

Abdullah Ahmad — Wed, 12 Aug 2026 19:19:35 +0000

If you have spent any significant amount of time building software with AI coding agents like Claude, Cursor, or GitHub Copilot, you’ve likely experienced the "Groundhog Day" effect.

AI agents are undeniably brilliant, but they share one massive, frustrating bottleneck: they are entirely stateless.

Every time you spin up a new chat session or switch contexts, you are forced to re-explain your entire project architecture, the nuances of your tech stack, and the design decisions you finalized yesterday. You spend 20 minutes meticulously prompting the AI so it understands why you structured your database a certain way, only for it to forget the moment the context window runs out or the session ends.

Eventually, the context collapses. You find yourself spending more time managing the AI's memory than actually writing code.

I got tired of repeating myself. So, I built a solution.

Enter the Vibe Coding OS
To fix the stateless nature of AI, we don't need a better LLM; we need a better system. We need to give our agents a persistent, structured memory drive.

Vibe Coding OS is a workflow and template system that connects Obsidian (the popular markdown knowledge-base app) to your AI agents using the Model Context Protocol (MCP).

Instead of relying on a fading chat window, you structure a local markdown vault as your project's "brain." Because MCP allows AI models to securely read and write to local files, your agent can dynamically interact with your notes in real time.

The Vault-as-Context System
The magic lies in how you structure the Obsidian vault. By using a standardized folder hierarchy, the AI always knows exactly where to look for rules, and exactly where to write its updates.

Here is the basic architecture of the Vibe Coding OS vault:

📂 /ideation: Where you brain-dump features, product requirements, and user stories. The AI reads this to understand the goal.

📂 /architecture: Your system diagrams, tech stack choices, and data models. The AI reads this to understand the boundaries.

📂 /dev-logs: The game-changer. After every coding session, the AI automatically generates a markdown log detailing what was changed, what bugs were fixed, and what needs to happen next.

📂 /debugging: A running ledger of persistent issues and error logs so the AI doesn't suggest a fix you already tried three days ago.

Every AI session pulls from real, structured context—not vague, degrading memory.

Why This Changes Everything
When you bridge the gap between an AI's reasoning capabilities and a persistent memory state, the entire development experience shifts.

Instant Context Loading: Your agent picks up exactly where you left off. You simply prompt, "Read the latest file in /dev-logs and let's start the next task," and the AI is instantly up to speed.

Persistent Logic: Design decisions are never forgotten or re-litigated. If the AI suggests an anti-pattern, it cross-references the /architecture folder and corrects itself.

Seamless Handoffs: Want to hand your project to another human developer? Or switch from Claude to a new agent? You just hand them the vault. They are instantly onboarded.

Auditable Build Process: Your entire development journey becomes tracked, auditable, and linkable.

Start Building with Memory
This is the actual unlock for serious "vibe coding." It brings engineering rigor to generative AI, transforming your agent from a forgetful intern into a dedicated senior partner.

I have open-sourced the exact Obsidian vault structure, template files, and the setup process for connecting it via MCP.

You can grab the full repository, clone the vault, and start building with memory today:

🔗 https://github.com/iabdullahahmad/VibeCodingOS

Stop re-explaining your codebase. Give your AI a brain.

Have you struggled with AI context limits in your projects? Let me know in the comments how you are currently managing your prompts and project context!

The End of Scattered Apps: Why You Need a Digital Workspace Kernel

Abdullah Ahmad — Mon, 10 Aug 2026 10:43:57 +0000

If you take a critical look at your digital environment right now, you will likely find a fragmented mess.

You probably have rough ideas jotted down in Apple Notes, project tasks scattered across Notion, reference PDFs buried deep in Google Drive, and crucial deadlines just floating around in your head.

The result of this setup is constant context-switching. You jump from app to app, trying to stitch together a cohesive picture of your work, your studies, or your projects. Ultimately, this friction leads to forgetting the things that actually matter.

We try to solve this by organizing our thoughts into elaborate, rigid folder hierarchies. But human psychology does not operate in isolated folders.

This is where a profound paradigm shift comes in. By treating your note-taking tool not just as a digital filing cabinet, but as a core workspace kernel, you can entirely eliminate the chaos. For a growing number of builders, creators, and students, the answer is a local-first application called Obsidian.

Here is why replacing your scattered apps with a unified, interconnected system completely changes the way you process information.

The Operating System Mindset
The biggest mistake most people make is treating their notes app as a simple dump for text. To build a system that actually scales, you have to shift your perspective. Obsidian is not just a place to write; it is personal infrastructure.

By centralizing your workflow, everything begins to interact within a single, seamless environment:

Knowledge & Courses: Managed through structured local folders and simple markdown (.md) notes.

Task Execution: Tracked directly inside the environment using Kanban plugins, keeping to-dos physically next to the relevant context.

Time Management: Deadlines and daily logs managed via integrated daily notes and calendar syncs.

The Ultimate Advantage: Everything links to everything else.

The Core Mechanic: Thinking in Links
Every standard productivity app treats files as isolated pages. You write a document, name it, and bury it in a folder.

Obsidian flips this entirely. Instead of pages, your notes become nodes. By wrapping any word in simple bracket syntax—like [[System Architecture]] or [[Cognitive Psychology]]—you instantly link notes together. As you do this, the system automatically generates a visual Graph View of your connected knowledge.

When you are managing complex projects or studying dense academic frameworks, this structure is a game-changer.

The Connected Workflow: Lecture or meeting notes link directly to required readings, which seamlessly connect to past project blueprints. When you need to prepare for a major exam or a client presentation, you can open your graph and instantly see every connected concept mapped out visually.

You no longer have to rely on folders. You can retrieve old thoughts exactly when they become relevant again.

A System That Actually Scales
The fundamental flaw of traditional note-taking is that every new semester or project feels like starting from zero. You open a blank document and leave your past insights in the dust.

When you utilize an interconnected system, your knowledge compounds.
You build the structural architecture once: Domain → Topic → Atomic Note.

Every new insight adds to the exact same digital brain. By year three of your university degree or your professional career, you don't just have a messy folder of outdated files. You possess a fully searchable, interconnected map of everything you have ever learned.

Because the entire system runs on universally readable Markdown files stored locally on your own computer, there is no cloud lock-in. Your thoughts are 100% offline, 100% yours, and entirely future-proof.

It is time to stop scattering your cognitive load across a dozen different apps. You do not need a better filing cabinet—you need an operating system for your mind.

Stop Hoarding Your Code Snippets: Why Obsidian is the Ultimate Developer Notebook

Abdullah Ahmad — Mon, 03 Aug 2026 16:54:46 +0000

If your workspace looks anything like mine, your notes are scattered across five different apps. You’ve got environment variables stashed in Apple Notes, half-finished system architectures in a Notion board, API keys in a random .txt file, and an endless stream of saved Stack Overflow links you’ll never look at again.

When you are juggling student life, freelance builds, and personal projects, you don't have the time or cognitive bandwidth to hunt down that one database schema you wrote three months ago.

We try to fix this chaos by organizing our thoughts into elaborate folder hierarchies. But here is the fundamental problem: your brain doesn't work in isolated folders.

When you’re designing an architecture, you aren’t thinking in silos. You’re relying on associative networks. This is where a paradigm shift called "networked thought" comes in, and why I’ve moved my entire development workflow to a local-first app called Obsidian.

The Folder Fallacy
Every standard productivity app treats files as isolated pages. You write a document, put it in a folder, and it goes into digital cold storage.

But whether you are deliberately applying System 2 thinking to a complex software design or just mapping out a new automated pipeline, insights happen when unrelated concepts collide. When you trap your backend API endpoints in a different folder than your user psychology notes, you destroy their ability to interact.

Obsidian flips this. Instead of pages, your notes become nodes.

Meet Obsidian: Local, Fast, and Future-Proof
Obsidian builds a web of your thoughts. For a developer, the underlying architecture is a breath of fresh air:

100% Local & Yours: No cloud lock-in. No SaaS subscription to access your own thoughts. Everything lives locally on your machine.

Future-Proof Markdown: Every note is just a .md file. It's lightweight, universally readable, and perfectly suited for developer documentation. You'll still be able to read these files in 50 years.

Git-Friendly: Because they are just local markdown files, you can version control your entire second brain using Git. Push it to a private repository and you have ultimate, free data security.

Thinking in Links (The Core Mechanic)
The magic happens in how Obsidian connects information. By wrapping any word in double brackets, you instantly link notes together, like [[Diffusion Models]] or [[MongoDB Atlas Schema]].

As you do this, Obsidian automatically generates a visual Graph View.

Here is what this looks like in practice:
Let's say you are engineering a Python-based AI Image Detector. You create a note for extracting embedded credentials. Instead of burying it in a rigid "Python Scripts" folder, you link it to your broader notes on [[Machine Learning]] and [[Digital Forensics]].

Months later, when you are building a cross-platform CLI tool for open-source information gathering, those old notes seamlessly resurface. The ideas compound. One concept naturally connects to ten others, sparking architectural insights and workflows you never explicitly planned out.

The Ultimate Dev Environment
You don't need another web app to store your code snippets. You need an environment that scales with your technical knowledge. With over 1,000 community plugins, you can integrate Obsidian with your terminal, execute scripts, connect to your n8n webhooks, and customize it to fit your exact workflow.

It’s time to ditch the folders and build a system that actually thinks alongside you.

This is just the surface of what networked thought can do. I am currently documenting how I use Obsidian as a complete operating system for code, study, and life. Drop a follow for Part 2!