DEV Community: Mustafa İlhan

Beyond the Prompt: Why "Harness Engineering" is the Real Successor to Prompt Engineering

Mustafa İlhan — Sun, 29 Mar 2026 10:05:39 +0000

If you’ve spent any time building with LLMs lately, you’ve likely hit the "ceiling of fragility." You craft the perfect prompt, and it works 80% of the time. But in production, that 20% failure rate is a nightmare.

Most people try to solve this with Prompt Engineering (words) or Context Engineering (data). But the frontier—led by teams at OpenAI and companies like Harness.io—is moving toward Harness Engineering.

The Technical Hierarchy: Prompt vs. Context vs. Harness

To understand why this works, you have to see where it sits in the stack:

Layer	Focus	Mechanism	The Goal
Prompt Engineering	The Message	Natural language instructions, few-shot examples.	Guiding the model's immediate response.
Context Engineering	The Memory	RAG, vector DBs, dynamic token management.	Providing the right "knowledge" at the right time.
Harness Engineering	The Environment	Deterministic guardrails, linters, sandboxes, and loops.	Ensuring the agent physically cannot commit a failure.

Why Harness Engineering Works: The "On the Loop" Principle

In traditional development, you are "In the Loop." You see a bug, you fix the code.
In Harness Engineering, you stay "On the Loop." If the agent makes a mistake, you don't fix the code; you fix the environment.

1. Deterministic Constraints (The "Brakes")

LLMs are probabilistic; they are "spiky" in their intelligence. A harness wraps that chaos in deterministic code. For example, instead of asking an AI not to break a dependency, you implement a custom linter that fails the CI build if it does. The harness turns a "suggestion" into a "physical law" of the repository.

2. The Verification Loop (Self-Healing)

A core component of the harness is the Write-Test-Fix cycle.

The Agent generates code.
The Harness automatically executes that code in a sandbox.
The Harness captures the standard error (stderr) and feeds it back to the agent. This moves the agent from "guessing" to "navigating" toward a passing test.

3. Machine-Readable Truth (`AGENTS.md`)

OpenAI’s team found that "tacit knowledge" (the stuff in your head or Slack) is the enemy of AI. A harness requires converting all tribal knowledge into a machine-readable format—like AGENTS.md or structural tests—that the agent can query as a "Source of Truth."

The Pros and Cons

The Pros:

Reliability: You move from "it usually works" to "it is verified to work."
Scalability: One engineer can manage 10+ agents because they are managing the system, not the output.
Legacy-Proof: As models get smarter (GPT-4 to GPT-5), your harness stays valid. You’re just putting a bigger engine in the same well-built car.

The Cons:

High Initial Overhead: You have to build the linters, the sandboxes, and the documentation first. It feels "slower" at the start.
Rigidity: A good harness limits what an AI can do. If you need a "creative" hallucination, a harness will kill it.
Technical Debt: If your harness isn't well-maintained, the AI will get stuck in loops trying to follow outdated rules.

The Shift in Your Job Description

We are moving from being Code Authors to Capability Architects. When you sit down to work now, your first question shouldn't be "How do I write this function?" It should be "How do I build a harness so that an agent can write this function—and a thousand others like it—without me ever touching the keyboard?"

How I Actually Use Prompt Router to Write Better Code (Not Just Faster)

Mustafa İlhan — Fri, 27 Mar 2026 16:54:16 +0000

I originally thought tools like Prompt Router were about “automatically picking the best AI model.”

That’s true—but it’s not why I kept using it.

What made it stick for me was something much more practical:

I can store prompts, refine them, and run them across multiple models to compare results.

That changed how I work way more than automatic routing ever did.

The Real Problem I Had

When coding with AI, I kept running into this loop:

Write a prompt
Get a decent answer
Wonder: “Is this actually the best I can get?”
Copy-paste the same prompt into another model
Lose track of which version was better

It was messy. And honestly, I wasn’t improving my prompts—I was just guessing.

What I Do Now (My Actual Workflow)

With Prompt Router, I treat prompts like reusable assets.

Instead of this:

random prompt → random result → forgotten

I do this:

Create a prompt template
Store it in the prompt library
Run it across multiple models
Compare outputs side-by-side
Refine the prompt
Repeat

It feels much closer to how we treat code:
→ iterate
→ test
→ improve

Concrete Example #1: Refactoring a Function

Let’s say I start with a basic prompt:

"Refactor this function to be more readable"

I’ll save it as a template and run it across:

one fast model
one strong reasoning model
one model that’s good at code style

What I notice:

Model A → fast but superficial
Model B → deeper structure changes
Model C → best naming + readability

Now I refine the prompt:

"Refactor this function into smaller functions, improve naming, and make it easier to test"

Run again → compare again.

👉 The key:
I’m not just getting answers—I’m learning what a good prompt looks like.

Concrete Example #2: Debugging

Prompt:

"Why is this async queue processing jobs twice?"

Running it across models shows something interesting:

One model → generic advice
Another → points to race conditions
Another → suggests idempotency + retry logic

Individually, each answer is incomplete.

But together?

→ I get a much clearer picture of the problem space

This is something I never got when using just one model.

Concrete Example #3: Designing Systems

When I work on architecture prompts like:

"Design a scalable event-driven system for handling payments"

Comparing models is incredibly valuable:

One focuses on infrastructure (Kafka, queues)
One focuses on data consistency
One focuses on edge cases and failures

Instead of picking “the best answer,” I:
→ combine the best parts

It’s like having multiple senior engineers giving input.

The Prompt Library Is the Underrated Feature

This part surprised me.

Saving prompts as templates means:

I reuse high-quality prompts
I stop rewriting the same instructions
I build a personal “prompt toolkit” over time

For example, I now have templates like:

“Refactor for readability + testability”
“Explain bug with root cause + fix”
“Generate production-ready code with edge cases”

And they keep getting better.

The Biggest Shift: Prompting Became Iteration

Before:

Prompting felt like guessing

Now:

Prompting feels like engineering

Test prompts
Compare outputs
Refine systematically

It’s basically:

Prompt development instead of prompt writing

Where Routing Still Helps (Quietly)

The routing part still matters—but more in the background.

While I’m comparing:

Simple prompts don’t waste powerful models
Complex prompts automatically hit stronger ones

So I get:

Better results
Lower cost
Without thinking about it

The Real Value (For Me)

Prompt Router didn’t just improve my outputs.

It changed how I think about using AI:

Prompts are reusable assets
Models are tools to compare, not commit to
Iteration beats guessing

Final Thoughts

If you’re only using one model, you’re missing something important:

AI isn’t about getting an answer.
It’s about exploring the space of possible answers.

Prompt Router makes that exploration easy.

And once you start comparing, refining, and reusing prompts…

…it’s really hard to go back.

Prompt Router: Write One Prompt. Open Every AI.

Mustafa İlhan — Sat, 21 Mar 2026 12:42:27 +0000

The Problem: AI Comparison is Tedious

If you use AI tools seriously — for writing, coding, research, marketing, or just exploring — you've hit the same wall. You write a prompt in ChatGPT. You get a decent response. Then you wonder: what would Claude say? Or Gemini? Or Perplexity?

So you open a new tab. Paste the prompt. Wait. Open another tab. Paste again. And again. And again.

By the time you've queried three different models, you've wasted two minutes on logistics that should take two seconds. The comparison itself — the interesting part — barely gets any time.

Copying and pasting across AI tools isn't a workflow. It's friction.

That's the problem Prompt Router solves.

What is Prompt Router?

Prompt Router is a free, single-page tool that lets you write your prompt once, then open it instantly in any of the major AI chat tools — prefilled and ready to go.

Visit here now prompt-router.pages.dev

No account. No login. No backend. Just you, your prompt, and every AI at your fingertips.

Supported providers:

ChatGPT — OpenAI's flagship model
Claude — Anthropic's model, great for nuanced writing and analysis
Gemini — Google's multimodal AI
Copilot — Microsoft's AI, integrated with the web
Perplexity — AI-powered search and research
DeepSeek — fast-rising open-weight model
Grok — xAI's model, with access to real-time X/Twitter data
Le Chat — Mistral AI's conversational interface

How It Works

The experience is intentionally minimal:

Land on the page — there's nothing to sign up for or configure.
Pick a quick template (optional) — ELI5, Compare, Brainstorm, Cold Email, Debug Code, and more.
Edit or write your prompt in the large textarea.
Click any provider button — the prompt opens in a new tab, prefilled and ready.
Or copy to clipboard with one click (keyboard shortcut: ⌘ + Enter).

That's it. Comparing five AI models now takes about 30 seconds.

Design Decisions Worth Mentioning

Zero friction by default

There's no onboarding flow. No modal asking for your email. No tutorial overlay. You land, you write, you send. Every second of unnecessary UI is a second stolen from actual thinking.

Templates that actually matter

The quick templates aren't generic filler. They're eight of the most commonly used prompt patterns across AI workflows: explain, compare, rewrite, summarize, brainstorm, debug, cold outreach, and decision analysis. Each template is designed to be edited, not just used — they include placeholders like [concept] and [paste code] that make the expected customization obvious.

Dark and light mode, automatically

The interface reads your system preference and adapts. Dark mode uses a near-black background with warm gold accents. Light mode switches to a warm parchment palette. Both are designed to be easy on the eyes during long sessions.

Keyboard shortcuts for power users

⌘ + Enter copies your prompt instantly. Escape clears the textarea when it's focused. These are small touches, but they matter when you're in flow and don't want to reach for the mouse.

Who Is It For?

Prompt Router is built for people who think carefully about AI outputs — not just people who use AI occasionally.

Prompt engineers who want to A/B test the same prompt across models
Developers evaluating which model handles a specific coding task best
Writers and marketers comparing tone and creativity across ChatGPT, Claude, and Gemini
Researchers cross-referencing answers from Perplexity and DeepSeek
Product managers using AI for competitive analysis, user interviews, and spec writing
Curious people who just want to see how differently models interpret the same question

If you've ever caught yourself copying a prompt into a third AI tool, this tool was built for you.

Under the Hood

Prompt Router is a single HTML file. No framework, no build step, no backend, no dependencies beyond two Google Fonts. It runs entirely in your browser.

A few technical notes for the curious:

URL prefilling works by appending your prompt as a query parameter to each provider's URL. Most major AI chat tools support this — though it can change without notice, and a few may not auto-submit.
Nothing is stored — the page has no analytics, no localStorage, no server. Your prompts never leave your browser.
Popup blockers can interfere with opening multiple tabs at once. If a tab doesn't open, the fallback is a one-click copy to clipboard.
PWA-ready — you can install Prompt Router on your phone or desktop as a standalone app via your browser's "Add to Home Screen" option.

Try It

Prompt Router is live and free at prompt-router.pages.dev. No account required, no time limit, no catch.

The next time you're about to open a second tab and manually paste your prompt, remember: there's a better way.

Supported Languages on Serverless

Mustafa İlhan — Mon, 02 Mar 2020 15:11:17 +0000

Serverless Architecture

Serverless architecture allows you to focus on the development of application without thinking about the details of the infrastructure. Therefore, it saves you time in the development of your application.

You develop your functions and handlers and then connect events to your handlers. That's it. This approach also called Function as a Service (Faas).

Serverless Infrastructure Providers

There are a couple of cloud providers that have serverless service. Major ones are Amazon Web Services (AWS), Azure, Google Cloud, Firebase, Cloudflare, IBM Cloud and Alibaba Cloud. There are differences between them in terms of supported languages, CPU, memory, etc. This article focuses on the supported programming languages of these cloud providers.

Serverless Languages

In the chart, the left-hand side lists the available programming languages and the right-hand side lists the cloud providers. If there is a link between language and cloud provider, that means this language is supported by that cloud provider. As you can see that not all languages supported by every cloud provider except AWS and IBM cloud has a Runtime API or Docker that supports every language on top of that. Javascript is the only language supported by every cloud provider.

In Serverless infrastructure, since you don't depend on infrastructure, you can easily switch between cloud providers. Therefore, the most important parameter here is the programming language that you develop your application.

Most recent version of supported languages can be reachable via this website https://serverless-lang.web.app/