Edmund (@Simply_Ed_) profile picture

Goal to become a 10x dev. Navigating complexities in today’s LLM driven software environment.

Joined February 2017
Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)Photo by Edmund (@Simply_Ed_)
Edmund retweeted
Your Claude loops can burn money while nothing changes Use Jev to filter tasks and cut decision costs Fix the trigger before another overnight run The full Loop engineering + Jev engineering setup below ↓
34
55
18
505
1,102,737
As an AI Engineer, you must build these projects. 1.) Dynamic Context Assembler Build: Middleware that strictly budgets tokens across working memory, tool schemas and retrieved docs per request. Why: Prompt engineering is dead. Context overflow is the #1 silent killer of production agents. 2.) Durable State Machine Workflow Build: Temporal or LangGraph DAG with checkpoints, exponential retries and human-in-the-loop Slack approvals. Why: Endless chat loops break in production. Real business workflows take days and must survive server crashes. 3.) Raw MCP Server & Client Build: JSON-RPC server exposing your database and internal APIs with scoped credentials without using a wrapper SDK. Why: Agents need standardized, secure hands to do real work. Bespoke API wrappers do not scale. 4.) System-One Triage Router Build: Proxy routing 95% of traffic to a fast, typed-decision model and escalating only 5% to a heavy reasoning model. Why: Sending every query to a frontier API burns your runway. Unit economics dictate survival. 5.) Self-Correcting Agentic RAG Build: Retrieval agent that critiques its own search results, rewrites ambiguous queries and confidently abstains if grounding is weak. Why: Naive chunk-and-retrieve RAG is a liability. Agents must know when to search again. 6.) 3-Tier Memory Engine Build: Working scratchpad, episodic session summaries, and semantic vector DB with automated importance scoring and eviction. Why: Agents without memory fail by turn five. Agents with infinite memory hallucinate from context bloat. 7.) Trajectory CI Gate Build: GitHub Action grading the agent's tool-call sequence against a golden DAG, blocking PRs if it deviates. Why: Final-answer evals hide the exact step where the agent went rogue. The trajectory is the unit of accountability. 8.) Inter-Agent Sanitization Proxy Build: Middleware preventing cross-agent prompt injection and enforcing least-privilege tool scoping per agent. Why: Multi-agent swarms create internal attack surfaces that standard unit tests completely miss. 9.) Real-Time Voice Interruption Loop Build: Streaming SSE/WebSocket agent with Voice Activity Detection (VAD) and sub-1s interruption handling. Why: The interface is moving off the screen. Perceived latency and interruption handling are the new UX standards. 10.) DPO Feedback Flywheel Build: Pipeline capturing user thumbs-downs, formatting them into preference pairs and triggering nightly LoRA fine-tunes. Why: Your production edge cases and failures are the highest-leverage training data you own. 11.) Cost Kill-Switch & Degradation Chain Build: Middleware halting agent loops instantly if projected spend exceeds $0.50, falling back Frontier → Mid → Local → Cache. Why: A runaway agent loop is an outage with an invoice. 12.) Shadow Routing Comparator Build: Silent 5% traffic mirror to a new model or prompt, diffing trajectories and costs without affecting live users. Why: You cannot A/B test non-determinism safely without shadow mode. 13.) Computer-Use Fallback Agent Build: Agent that tries the REST API first, then seamlessly spawns a headless browser if the endpoint 404s. Why: The real world runs on legacy portals with no documentation. 14.) PII Unmasking Proxy Build: Gateway swapping sensitive data for UUIDs before the context window and restoring it post-generation with audit logs. Why: Enterprises will not touch agents that leak customer data to frontier models. 15.) Public Architecture Teardown Build: 3 published deep-dives with system diagrams, cost/latency benchmarks and architecture decision records (ADRs). Why: Senior AI engineers are hired for their system design judgment not their wrapper skills. Systems that prove you can orchestrate, secure & scale when agents touch your stack. Bookmark & Repost.
If I had 6 months to become an AI Engineer in the Agentic Era. I’d do this. Stage 1: Context Engineering & Token Economics - Learn: Token math, context window limits, dynamic assembly, context compression, budget allocation. - Practice: Build a dynamic context assembler that strictly budgets tokens across working memory, tool schemas and retrieved docs per request. - Why: Prompt engineering is dead. Context overflow is the #1 silent killer of production agents. Stage 2: Durable Agent Orchestration - Learn: State machines, Temporal, LangGraph, checkpointing, human-in-the-loop (HITL) gates. - Practice: Build a 4-hour agent workflow that survives server crashes, API timeouts and waits 3 days for human approval before resuming. - Why: Endless `while True` chat loops break in production. Real business workflows require durable execution. Stage 3: Tool Use and MCP (Model Context Protocol) - Learn: JSON-RPC, strict Pydantic schemas, tool discovery, scoped credentials, MCP servers/clients. - Practice: Write a raw MCP server from scratch exposing your database and internal APIs without using a wrapper SDK. - Why: Agents need standardized, secure hands to do real work. Bespoke API wrappers don't scale. Stage 4: System-One vs. System-Two Routing - Learn: Typed decision models (Jev-style), confidence scoring, latency vs. cost tradeoffs, model cascades. - Practice: Build a triage router that sends 95% of traffic to a fast System-One model and escalates only the 5% edge cases to a heavy reasoning model. - Why: Sending every query to a frontier reasoning model burns your runway in a week. Unit economics dictate survival. Stage 5: Advanced Agentic RAG - Learn: Contextual retrieval, GraphRAG, query rewriting, self-correction, hybrid search, abstention logic. - Practice: Build a RAG agent that critiques its own search results, rewrites ambiguous queries and confidently refuses to answer if grounded context is weak. - Why: Naive chunk-and-retrieve RAG is a liability. Agents must know when to search again. Stage 6: 3-Tier Memory Architectures - Learn: Working memory (scratchpad), Episodic (compressed session logs), Semantic (vector DB), eviction policies. - Practice: Build a memory engine that automatically compresses, scores and evicts old context to keep the agent sharp over long sessions. - Why: Agents without memory fail by turn five. Agents with infinite memory hallucinate from context bloat. Stage 7: Trajectory Evals & CI Gates - Learn: Step-level grading, LLM-as-a-judge calibration, golden datasets, regression testing, shadow routing. - Practice: Build a CI pipeline that grades the agent's tool-call sequence and blocks PRs if it deviates from the golden path. - Why: Final-answer evals hide the exact step where the agent went rogue. The trajectory is the unit of accountability. Stage 8: Inter-Agent Security & Guardrails - Learn: Prompt injection defense, PII masking, least-privilege tool scoping, sanitization proxies. - Practice: Build a middleware that swaps PII for UUIDs before the LLM sees it and prevents Agent A's output from injecting Agent B. - Why: Multi-agent swarms create internal attack surfaces that standard unit tests completely miss. Stage 9: Real-Time Multimodal & Voice UX - Learn: Server-Sent Events (SSE), WebSockets, Voice Activity Detection (VAD), interruption handling, optimistic UI. - Practice: Build a voice agent with sub-1s interruption handling that streams tool calls and text simultaneously. - Why: The interface is moving off the screen. Perceived latency and interruption handling are the new UX standards. Stage 10: The DPO Data Flywheel - Learn: Preference pairs, LoRA fine-tuning, automated feedback loops, synthetic edge-case generation. - Practice: Automate a pipeline that captures user thumbs-downs, formats them into preference pairs, and triggers a nightly model fine-tune. - Why: Your production edge cases and failures are the highest-leverage training data you own. Stage 11: FinOps & Graceful Degradation - Learn: Semantic caching, cost kill-switches, fallback chains (Frontier → Mid → Local → Cache). - Practice: Build a middleware that halts an agent loop instantly if projected spend exceeds $0.50 and degrades to a cached response. - Why: A runaway agent loop is an outage with an invoice. Stage 12: Public Teardowns & System Portfolios - Learn: Architecture decision records (ADRs), benchmarking, system diagramming, public writing. - Practice: Publish 3 deep-dives on how you reduced agent latency, cut inference costs or improved tool-call accuracy by 80%. - Why: Senior AI engineers are hired for their system design judgment not their API wrapper skills. Wrappers are a commodity. Systems engineering is the moat. The modern AI Engineer builds the deterministic harness around the stochastic brain. Bookmark and Repost!
42
105
7
1,233
90,951
It is and always will be an agency thing. In a lot of aspects of our lives things are easier than ever to do. You can lead a horse to a water but cant make it drink. When you can outsource reliability to others while you focus your time on your specialty, why would you bother?
I'd call this a bubble in a bubble Tech people somehow still think normies are not spinning up personal software already They're not doing it in Claude Code in a terminal like tech people for sure But their AI chat app is already doing it for them without them even realizing they're building personal software, like generating PDF reports, full web app dashboards and even entire web apps That will keep getting more advanced and soon ChatGPT will just spin up a Photoshop clone (but ofc only if they need it, preferring to just do their photo edits for them) Everyone will mostly use personal ephemeral software inside AI chat apps I think Some software moats will remain like social media (community), ecommerce (think like Shopify and Stripe), etc but they will just be used by AI to build the personal software with So maybe that's the point here, become a tool agents use to solve their user's problems and charge agents for it (like many are saying)
35
On ai twitter for past two days
40
Edmund retweeted
How have software engineering fundamentals changed with agentic coding? Here is our AI Engineering Skills map for software engineering fundamentals.
349
1,476
162
8,810
1,164,104
Andrew Ng just released a 2-hour course on full Graph Engineering. How to go from one prompt to 100 agents that loop, rewrite themselves, and run without you: 09:14 - Build your first AI agent 33:11 - Run agents with loop engineering 1:02:46 - Turn agent loops into graphs 1:30:15 - Build agents that rewrite themselves 1:49:05 - Run the full graph system without you Most people are still building one agent and calling it done. Andrew Ng is already teaching everything after: Prompt → Agents → Loops → Graphs → Self-Improving Systems Single agents are the old workflow. Systems that improve and run without you are the new one. This 2-hour watch is worth more than most $500 agent engineering courses. Bookmark and watch it before everyone catches up. Then read how to run 1,000 agents from one prompt below ↓
32
175
8
1,040
227,814
Edmund retweeted
Google just dropped a free 2-hour course On turning one prompt into an agent graph that builds itself: 10:16 - Build your first AI agent 41:05 - Engineer prompts that work 54:45 - Connect agents into graphs 1:20:10 - Run loops inside agent graphs 1:43:33 - Build a self-evolving graph Most people ship one agent and stop there Google is already teaching everything that comes next: Prompt → Agents → Graphs → Loops → Self-Building Systems Single agents are the old workflow Graphs that evolve themselves are the new one This free 2-hour course is worth more than most paid agent engineering programs Bookmark and watch it today Then read how to run 1,000 agents from one prompt below ↓
9
15
123
13,850
list of 10 active AI researchers on X: 1. @karpathy — Andrej Karpathy 2. @rasbt — Sebastian Raschka 3. @AndrewYNg — Andrew Ng 4. @drfeifei — Fei-Fei Li 5. @demishassabis — Demis Hassabis 6. @GaryMarcus — Gary Marcus 7. @ai_explorer25 — AI Explorer 8. @maximelabonne — Maxime Labonne 9. @chipro — Chip Huyen 10. @ilyasut — Ilya Sutskever
8
28
226
32,958
Nice 1K stars in a day - people are sick of slop! github.com/petergyang/no-ai-…
I’m sick of reading AI slop, so today I’m open-sourcing my /no-ai-slop skill that removes 20+ slop patterns from any piece of writing. 📌 Get the free skill here: github.com/petergyang/no-ai-… If you find it useful, please consider starring the repo so more people can find it. Why I built the skill: I use AI to edit my writing because it helps me fix spelling, grammar, and clarity. But even the best models keep producing the same slop that this skill removes: → Binary contrasts: “It’s not X. It’s Y.” → Throat-clearing openers: “Here’s what nobody tells you.” → Fake-profound endings: “The future isn’t coming. It’s already here.” Use this skill responsibly. I always write a first draft manually before iterating with AI on edits and I make sure to do another manual pass at the end as well. That’s in contrast to using AI to automate pumping out slop end-to-end. 📌 Read my full post for more on how I try to use AI responsibly to edit without giving into the dark side: creatoreconomy.so/p/use-my-n…
9
5
91
14,964
/teach is live Learn anything, from rubik's cube to vocal harmonies to software fundamentals. npx skills add mattpocock/skills --skill teach Best skill I've ever built, video coming soon github.com/mattpocock/skills…
81
173
17
2,816
164,742
Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.
1,786
1,395
1,466
19,913
8,705,232
> do you understand what just happened to the job market > one person + 67 Claude Skills > does the work of an entire dev team > $20/month vs $200K/year in salaries > the Google engineer who automated 80% of his job? > this is the exact skill list he used > bookmark this. seriously. right now. 👇
65
149
6
2,190
1,020,641
Every engineer should read this. The principles for building reliable software systems have been around for a long time. Max outlines them beautifully. Here's to getting that 99.99% on your status page. planetscale.com/blog/the-pri…
23
168
8
1,662
114,940
Claude Code feels completely different once you install this. Anthropic quietly released an official plugin called claude-code-setup and it basically turns Claude Code from “pretty good” into an actual AI dev environment. It scans your project and recommends: → hooks → skills → MCP servers → subagents → automations Then sets everything up step-by-step for you. Most people are using Claude Code completely vanilla… which is why their experience feels messy. The real power comes from the ecosystem around it. Install: /plugin install claude-code-setup@claude-plugins-official Bookmark this before you forget it.
Readers added context they thought people might want to know
The official claude-code-setup plugin analyzes projects and recommends hooks, skills, MCP servers, subagents, and automations but does not install or set them up, as it operates in read-only mode without modifying files. claude.com/plugins/claude… github.com/anthropics/cla…
130
405
36
4,454
1,557,565