I’ve spent the last few weeks experimenting with AI development via Claude, GPT, and Gemini – turning them into systems that ship working software, not just generate code.
Here’s what I actually learned:
Prompt Engineering
Most of us are doing it wrong. The difference between a generic config file and an optimized execution kernel is the difference between a model that occasionally produces good code and one that autonomously ships.
Stop explaining what the model already knows. Every token spent on trained knowledge – error handling, TDD, test pyramids – dilutes the novel instructions that actually change behavior. Use trigger phrases, not textbooks.
And design for the architecture, not the interface. LLMs look like they understand natural language, so people write natural language instructions. But the underlying system is a statistical token predictor with finite attention. Design instructions like protocols: conditional branching, explicit triggers, quantified gates.
LLM Architecture
Instruction adherence under load is the most expensive weakness across all models. The failure mode is identical – attention dilution, helpfulness gravity, autoregressive momentum. The threshold varies, but the cliff exists for everyone.
There is no fix, only mitigation. Until architectures change (persistent state registers, privileged instruction rings), the best we can do is: compress to reduce dilution, checkpoint to force re-engagement, and delegate to reset the attention budget.
Sub-agent delegation is attention budget recovery, not just parallelism. A fresh context means full attention weight on protocol instructions. This is the most powerful practical defense against the dilution problem.
Instruction Delivery Architecture
MCP beats system prompts for protocol delivery. Server-enforced gates, recency-positioned instructions, and externalized state tracking solve every architectural cause of instruction adherence failure that system prompts can only mitigate.
The optimal design is hybrid. A minimal config file bootstraps the MCP protocol. Cross-cutting concerns stay in the system prompt. Stateful protocol execution lives in the MCP server. Less attention cost, full protocol fidelity.
MCP makes the model’s job simpler. “Call a tool and follow the response” is a well-trained behavior. “Follow a complex multi-step protocol from 50,000 tokens ago” is not.
Competitive Positioning
The moat is the system, not any single technique. Individual innovations can be copied. A self-reinforcing system with state machine execution, quantified quality gates, and memory-augmented learning cannot be replicated by copying features.
Memory creates compound advantage. Session 100 is better than session 1. Switching to a competitor means starting from zero.
And honest self-assessment is a functional advantage. Quality scorecards are useless with inflated scores. Assumption ledgers are useless without flagging uncertainty. Models trained to appear confident undermine their own quality gates.
The biggest takeaway? The models are good enough. The bottleneck is instruction design. Most of us with a non-programming background aren’t treating it as an engineering discipline – but we should be.
Disclosure: This post may contain affiliate links. If you purchase through these links, we may earn a commission at no extra cost to you. See our Affiliate Disclosure for details.