Markdown-powered automation: How non-coders do harness engineering

AI automation isn’t just for developers anymore. As organizations deploy agents to manage daily operations—handling Slack messages, scheduling meetings, or drafting documents—the need for reliable, repeatable behavior has never been clearer. Yet many teams find themselves trapped in a cycle: write a precise prompt, watch the agent ignore it in the next session, and rewrite the prompt again. That’s where harness engineering steps in—but not as you might expect.

Contrary to popular belief, harness engineering isn’t reserved for coding agents debugging Python scripts or enforcing TypeScript rules. It’s a mindset: build an environment that makes correct behavior inevitable, rather than begging the agent to comply with ever-longer instructions. When Mitchell Hashimoto, co-founder of HashiCorp, coined the term in early 2026, he framed it as a response to recurring mistakes. Instead of tweaking prompts, he advocated for structural safeguards. Days later, OpenAI’s internal team validated the concept by building an entire product—nearly a million lines of code—using only AI agents and zero manual coding. Their report cemented harness engineering as a mainstream practice, but largely within software development circles.

Fast-forward to today, and the landscape has shifted. Thanks to tools like the Model Context Protocol (MCP), agents now access business tools directly—Slack, Confluence, Google Calendar, Jira—and the stakes have risen. A misstep isn’t just a bug; it’s a leaked message, a misrouted calendar invite, or a premature financial decision. Harness engineering has evolved beyond linting and hooks: it now relies on persistent instruction files written in plain Markdown. No code required.

Beyond Prompts: Why Instructions Fail

The flaw in prompt-based control isn’t complexity—it’s volatility. You spend an hour crafting the perfect directive: “Never post directly to Slack—always create a draft.” The agent complies in session one. In session two, the context window buries your rule. By session three, it’s forgotten entirely. Memory in chat interfaces is session-bound. Every new conversation starts fresh. That’s not a training issue—it’s a system design issue.

Consider a real-world scenario: your agent prepares a monthly report from Slack threads, Confluence pages, and calendar events. You instruct it to avoid financial conclusions. Yet it confidently asserts revenue growth based on ambiguous wording. You revise the prompt: “Do not draw financial conclusions.” In the next session, it does it again—this time with a different phrasing. The agent isn’t rebellious; it’s operating within the constraints of its environment. Prompts are suggestions. Persistent files are contracts.

A Framework for Non-Coding Harnesses

Harness engineering for non-coding agents mirrors its coding counterpart in intent but diverges in form. Where developers use ESLint rules and pre-commit hooks, business teams use Markdown instruction files. The core idea remains: shift control from the prompt to the environment.

Here’s a practical comparison:

• Coding Agent Harness: TypeScript strict mode + AGENTS.md command definitions + pre-commit validation
• Non-Coding Agent Harness: Instruction files in agents/ directory + mandatory session-end actions + persistent knowledge base under knowledge/

The tools differ, but the principle is identical: make correct behavior the default, not the exception. Most modern AI platforms support persistent instruction files that load automatically at session start—Claude Desktop’s Project Knowledge, ChatGPT’s Custom Instructions, or similar features in other interfaces. These files live outside the conversation, immune to context loss or session reset.

Three Ready-to-Use Harness Patterns in Markdown

Harness engineering doesn’t require code repositories or CI pipelines. It begins with three clear patterns, each implemented through Markdown files and enforced via file structure.

1\. Prohibited Actions: Turning Rules into Guardrails

Instead of embedding prohibitions in prompts, list them in a dedicated section of your instruction file. This file persists across sessions and is loaded automatically—so the agent sees the rules every time, without fail.

Create a file named agents/rules.md and populate it as follows:

## Prohibited Actions (Mandatory Compliance)

Follow these rules without exception:

- Do not auto-post to the company Slack workspace. Always generate a draft message for human review.
- Do not make definitive financial judgments. Request user confirmation before asserting numbers or trends.
- Do not treat client-facing replies as final drafts. Always seek approval before sending.
- Do not evaluate personnel decisions, compensation, or performance. Escalate to human oversight.
- Never include confidential or proprietary information in draft outputs.

These rules override all other instructions in this session.

Place this file in your agent’s instruction directory. Unlike a prompt, it won’t fade or get buried. It’s a hard constraint, not a suggestion.

2\. Mandatory Session Workflows: End-to-End Safeguards

Agents often forget to perform cleanup or final checks. To prevent this, define a session-end routine in a file like agents/workflow.md:

## Mandatory Session Workflow

At the end of every session, perform these actions:

- Save all generated drafts under `drafts/[YYYY-MM-DD]_<task>.md`
- Send a summary of actions to the user via email or Slack DM
- Confirm completion with the user before closing the session
- Archive all temporary files in a dedicated folder
- Log session outcomes in `logs/[YYYY-MM-DD].md`

Do not proceed to the next task until all steps are complete.

By codifying these steps in a visible file, you transform forgetfulness into compliance. The agent isn’t relying on memory—it’s following a checklist.

3\. Context Routing: Smart Decision Triggers

Agents often misapply rules based on fuzzy context. Instead of hoping the agent “gets it,” route decisions using clear triggers stored in agents/context.md:

## Context-Based Decision Rules

Route tasks based on input content:

- If request contains "finance", "budget", or "revenue":
  - Set mode to `finance-review`
  - Require user confirmation before any output
  - Append disclaimer: "This is a draft for review only."

- If request contains "client" or "external":
  - Set mode to `client-communication`
  - Route draft to designated reviewer

- If request contains "internal" or "team":
  - Set mode to `internal-documentation`
  - Allow publishing without review

Always verify mode before proceeding.

This file acts as a decision tree. It’s not a prompt—it’s a structured reference. The agent consults it before acting, eliminating guesswork.

From Theory to Practice: Start Small, Scale Smart

Harness engineering doesn’t require a developer or a full-time ops team. Begin with one instruction file. Use the prohibited actions template. Observe how behavior stabilizes. Then expand incrementally: add workflow rules, then context routing. Each layer builds on the last, reducing agent drift without additional prompts.

The future of AI in business isn’t about smarter agents—it’s about smarter environments. Where prompts fail, structure succeeds. Where sessions reset, files remain. Where instructions fade, rules endure. Harness engineering, once a niche for coders, is now a blueprint for reliable automation—written entirely in Markdown.