Design Principles

You know the motion:

1. Doing some work → Need some type of help
2. Open a chat → Type a prompt → [wait] → Read the response (repeat)
3. Copy/Paste response back into ‘working version’ → Continue work

Many people use “AI” like this today. It’s easy, and it works: you get answers and save time.

Changes are also happening at a rate we’ve never seen before. Models are getting better, responses are getting more robust. Companies are rapidly launching new products; others are integrating with AI tools. It’s showing up everywhere.

This is one of arguably THE largest technological transformations in our lifetime.

I see a problem looming on the horizon, and pose this question:

“Is “chatting with AI” the way you plan to scale your business and compete?”

Our inverted relationship with AI

For the last three years, I’ve struggled with this inverted inverted relationship with AI.

When working with clients new to AI, there is often this moment during design when they realize AI is not this ✨magical✨ thing that gets turned on and just starts doing their work.

I, like many of my clients, have big expectations for what AI can do for me.

But, many non-technical, AI-curious users are somewhat stuck at the moment. They have access to this incredibly powerful tool, but…

AI only does things when they ask it.

---

I’ve spent a lot of time thinking and building solutions around this limitation.

”How do I turn the tables and begin realizing automated benefits from AI?”

I started putting together a wish list; things I want in an AI platform:

• a system that is NOT dependent on me to initiate every task
• “agents” that can do real work, not just answer questions
• …that I trust to make decisions on my behalf
• feels like having a real team working with me…
• …but NOT an inexperienced team I constantly need to babysit
• enables me to work on other things …
• allows me control and observability

It’s difficult to find a single product or tool that will deliver on all of these requirements in an integrated, flexible, safe manner. There are a flood of products hitting the market, but (for me), too early to commit to any one of them. And…I don’t want to wait.

So, I built my own platform that does exactly what I want.

---

The chat ceiling

Like many, I started with tools like ChatGPT.

It was impressive what I could ask and it created. I started incorporating it in my personal and professional life in every way possible.

Unfortunately, the productivity gains hit a ceiling. I was constantly typing similar commands then copying/pasting content somewhere else to work with it.

I began looking for ways to speed up this process.

I quickly graduated to third-party apps like Msty, BoltAI, Open WebUI, LibreChat, etc. These tools allowed organization of reusable prompts and had placeholders to make them dynamic.

These were all great tools, each one doing a similar-ish thing. I quickly acquired a warehouse of reusable prompts, saved chats, and even different models for different needs, including using local/free open source models. All cool stuff…

But I was tethered to the screen, and I certainly wasn’t typing any less.

All of the tools I was using shared the same flaws as before:

• they were still just chat
• no context of who I was, what I was working on, etc. unless I told it every time
• difficult to control just the right info at the right time
• responses needed to be copy/pasted somewhere to be actually useful.

---

Nothing against chat

It’s worth a pause here to clarify…

Chat is the current standard for engaging with AI, and I’m not suggesting it is the problem. For general questions and requests, chat works great. But for bigger and on-going tasks, a better, more scalable interface is needed.

The biggest flaw chat has: it doesn’t scale. Chat requires YOU to write the prompt, YOU to read the responses, YOU to incorporate and YOU to review the work. (ALWAYS review the work!)

When you want AI to do more for you… YOU are the bottleneck!

---

Bringing AI to the content

Claude Code released around February 2025. It changed the game. It allowed me to do two things I couldn’t before:

• Context: have AI work directly with content, reading and writing files
• Tools: write and run code to do things in a predictable way and connect to other systems

Adding context to a chat was now natural: Before you begin, read @path/to/file.

Also, a CLAUDE.md file could be created in any folder. When Claude works with files in that folder, it automatically reads that file, getting additional context about the directory, processes, standards to follow, etc. without me adding it to each request.

Tools unlocked predictable outcomes and data movement.

“I” built a local toolbox of Python scripts and third-party integrations that Claude Code could use to write Google Docs, update Salesforce, etc. Claude Code was now reading and writing the actual content I was working with AND helping me build even more AI/tools to expand. This was a major compound effect I hadn’t experienced before.

Big win: it eliminated a lot of the copy/paste tasks!

But yet…here I was, still in chat and, in a terminal.

Five chat windows meant five times the output… and five times the babysitting.

I was still the one deciding what to work on, initiating the discussion, checking for results, etc. The productivity gain was real, but still only scaled linearly with more of my time.

The unanswered question kept nagging me:

What does it take to go from chat to real autonomy ?

Not just “AI-assisted” — but AI-driven.

At the time, nothing really existed in market. So I set out to build something.

---

My first real ah-ha moment

Things unlocked when I let Claude Code loose on my Obsidian “second-brain” notes.

A simple command now initiated Claude, instead of me, automatically every ~30 minutes.

Chat prompts morphed into process/workflow instructions:

1. discover upcoming meetings (empty notes)
2. read previous meetings for context/goals
3. write prep notes based on goals. e.g. What questions should I ask?
4. after meeting, review then summarize notes and transcripts
5. re-qualify sales opportunities and write next steps
6. what should I improve on in my next meeting?

This upgrade was real movement, and I have to admit there were some ‘perma-grin’ days in there.

The system was slightly fragile and hinged on watching the ‘state’ of content closely. Agents were reading/writing the same files I was working with. This is what I wanted, but the workflow had expectations built-in.

If a file didn’t look as expected, sometimes the agent made assumptions. It was like working with a teammate that did great work, but I couldn’t communicate with in real-time.

⊕ I actually had time to prepare and manually entered some notes …
⊖ Agent assumed it was placeholder and it was overwritten

⊕ I was too busy talking signature process with the client… didn’t take notes …
⊖ Agent updated deal “At risk” b/c: no notes meant ‘the client didn’t show up’.

Net-net: Was this still saving me time? Oh yeah!

It wasn’t ‘fully-hands off’, like many people are expecting with AI today. But there were also secondary benefits that often get over-looked: data completeness and quality in the responses were both crazy good, just needed to work through consistency.

---

With new learnings in mind, it was now time to go bigger ! Let’s give agents what they want.

If I had asked people what they wanted, they would have said faster horses.

---

I did this so you could all learn a lesson

(that’s a lie)

Unfortunately, what came next was a massive over-pivot on structure and control.

My experience so far was that agents thrived working within tightly controlled situations.

I also wanted to start building more new things with AI. This meant aligning with agents on why and exactly what & how things should work.

So, that’s what I set out to build: a fully deterministic orchestrator, structured workflows, schema validated models, and Jinja2-hydrated prompt templates.

The works. So, I could go hands-off.

In this system, every step would become prescribed, tuned, and managed. Every output structured and validated. This control meant I could tune and optimize every step from dynamic context injection to rubric-validated results.

Tasks were configured with files that looked like this.

  
feature:
  name: "build-deal-qualifier"
  pipeline:
    - stage: plan
      template: templates/plan.j2
      validation: schemas/plan.schema.json
    - stage: implement
      template: templates/implement.j2
      validation: schemas/code-output.schema.json
    - stage: verify
      template: templates/verify.j2
      max_retries: 3
  constraints:
    allowed_paths: ["src/", "tests/"]
    blocked_commands: ["rm", "git push --force"]
  
    
  
  
  

It took awhile, but came together, and worked very well. I’m proud of the work that went into this and the learnings were invaluable.

And, you guessed it: Agents loved it.

— But…

(I know someone reading this right now is laughing…)

I hated it.

I was spending more time on the platform than on what it was supposed to be producing.

This was next-level babysitting. Every new task meant updating schemas, writing templates, and wiring up validations before an agent could do anything useful.

The deliverable wasn’t the platform… I had completely lost flexibility.

I knew I needed to dial things way back, but not abandon the learnings I gained so far. I had all the pieces now - it just needed to be thoughtfully executed.

It prompted a new question to solve:

“What do you actually NEED to control in an agentic platform?”

— and what can you leave up to the agent to handle…

Case in point: The first deliverable was not the system, but five principles that every feature of the platform needs to operate from.

So that’s what I want to share, because I think these are far more important to a system than exactly what script runs where.

---

Five Principles for an Agentic Platform

These aren’t theoretical ideas. Nor can anyone say they are “best practices” (yet).

Each one exists because I got burned somewhere in a previous phase.

What’s Next

When I hear someone say “AI isn’t that good yet,” it’s often because the model hasn’t been given a fair chance to succeed.

AI isn’t ✨ magic ✨.

Closing Thoughts:

The value gap is no longer model capability — it’s implementation: context, control, and continuous-improvement.

AI can’t read your mind. But big opportunities are here.

Give a model the right information at the right time for the specific task… the results can be exactly what you want (consistently). Most of my platform is just solving for these things.

Next read is probably: v1 Implementation

---

Now, time for me to go move some of those issues to Ready!