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,743
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
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,811
1,164,113
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,233
> 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,642
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
As a Senior Backend Engineer trying to move towards Staff, I can tell you one thing clearly: At Senior level, knowing system design fundamentals is not enough anymore. You are expected to design a good system. At Staff level, you are expected to design the right system for the business, explain the tradeoffs, influence multiple teams, reduce long term operational pain, and make sure the system does not collapse when traffic, teams, and complexity grow. So if you are already good at system design but still feel stuck at Senior, spend the next 3-6 months building these Staff Engineer muscles. Architecture & Technical Strategy ↬ System boundaries ↬ Platform thinking ↬ Build vs buy decisions ↬ Monolith decomposition ↬ Multi-region architecture ↬ Migration strategies ↬ Backward compatibility ↬ API contracts ↬ Long-term maintainability ↬ Reducing operational complexity ↬ Designing for org structure ↬ Architecture decision records ↬ Technical roadmap planning ↬ Removing accidental complexity ↬ Identifying single points of failure ↬ Choosing boring technology ↬ Knowing when not to build ↬ Designing systems that teams can own Scalability & Distributed Systems ↬ Caching strategy ↬ Queueing strategy ↬ Partitioning ↬ Sharding ↬ Replication ↬ Leader election ↬ Rate limiting ↬ Load shedding ↬ Backpressure ↬ Fan-out/Fan-in ↬ Idempotency ↬ Retry storms ↬ Consistency models ↬ Eventual consistency ↬ Distributed transactions ↬ Data locality ↬ Hot partitions ↬ Graceful degradation ↬ Capacity planning ↬ Failure mode analysis Databases & Data Architecture ↬ Data modeling ↬ Indexing strategy ↬ Query patterns ↬ Read/write scaling ↬ OLTP vs OLAP ↬ CDC ↬ WAL ↬ Transaction isolation ↬ Schema evolution ↬ Data retention ↬ Backup and restore ↬ Archival strategy ↬ Hot/cold storage ↬ Multi-tenant data design ↬ Event sourcing ↬ CQRS ↬ Denormalization tradeoffs ↬ Data correctness ↬ Reprocessing pipelines ↬ Analytics vs product database separation Reliability & Operations ↬ SLO/SLI/SLA ↬ Error budgets ↬ Alert quality ↬ Incident response ↬ Postmortems ↬ Runbooks ↬ On-call pain reduction ↬ Canary deployments ↬ Rollbacks ↬ Feature flags ↬ Disaster recovery ↬ Load testing ↬ Chaos testing ↬ Health checks ↬ Circuit breakers ↬ Distributed tracing ↬ Metrics design ↬ Log quality ↬ Dependency failure handling ↬ Designing for recovery, not perfection Execution & Influence ↬ Writing design docs ↬ Getting alignment ↬ Mentoring seniors ↬ Reviewing architecture ↬ Asking better questions ↬ Challenging vague requirements ↬ Explaining tradeoffs simply ↬ Driving cross-team projects ↬ Creating technical standards ↬ Reducing duplicate systems ↬ Unblocking other teams ↬ Making hidden risks visible ↬ Communicating with product ↬ Saying no with reasoning ↬ Turning ambiguity into execution ↬ Making other engineers more effective The Senior to Staff jump is not just about “I can build complex systems.” It is: “I can help the org make better technical decisions, avoid expensive mistakes, and create systems that other engineers can safely build on top of.” That is the mindset shift imo.
As a Principal Backend Engineer with over 12 years of experience, I can tell you quite certainly that if you're still getting rejections in system design interviews after good efforts, I think your fundamentals are not strong... Dedicate 2-3 months to mastering these design fundamentals, then practice designing a few systems(and do plenty of mock interviews). Scaling & Architecture ↬ CDN ↬ Caching ↬ Sharding ↬ Queueing ↬ Replication ↬ Partitioning ↬ API Gateway ↬ Rate Limiting ↬ CAP Theorem ↬ Microservices ↬ Load Balancing ↬ Fault Tolerance ↬ Database Scaling ↬ Service Discovery ↬ Consistency Models ↬ Eventual Consistency ↬ Distributed Transactions ↬ Monolith vs Microservices ↬ Leader Election Databases & Storage ↬ Leader-Follower Replication ↬ WAL (Write Ahead Log) ↬ Asynchronous Processing ↬ Transaction Isolation ↬ Read/Write Patterns ↬ Consistent Hashing ↬ Redis/Memcached ↬ Backup & Restore ↬ Hot/Cold Storage ↬ Data Partitioning ↬ Object Storage ↬ SQL vs NoSQL ↬ Data Retention ↬ Data Modeling ↬ OLAP vs OLTP ↬ ACID & BASE ↬ Bloom Filters ↬ File Systems ↬ S3 Basics ↬ B+ Trees ↬ Indexing Communication & APIs ↬ JWT ↬ CORS ↬ OAuth ↬ Throttling ↬ Serialization ↬ API Security ↬ Long Polling ↬ WebSockets ↬ API Gateway ↬ Idempotency ↬ Service Mesh ↬ Retry Patterns ↬ REST vs gRPC ↬ API Versioning ↬ Circuit Breaker ↬ API Rate Limits ↬ Fan-out/Fan-in ↬ Protocol Buffers ↬ Message Queues ↬ Dead Letter Queue Reliability & Observability ↬ Metrics ↬ Alerting ↬ Failover ↬ Logging ↬ Rollbacks ↬ Monitoring ↬ Heartbeats ↬ Retry Logic ↬ Autoscaling ↬ SLO/SLI/SLA ↬ Load Testing ↬ Error Budgets ↬ Health Checks ↬ Circuit Breaker ↬ Incident Response ↬ Chaos Engineering ↬ Distributed Tracing ↬ Canary Deployments ↬ Graceful Degradation ↬ Blue-Green Deployment
20
122
8
1,244
150,587
I have a friend who wanted to become a senior engineer very early in his career. Just because he wanted the title badly. And he was tired of feeling average. He used to say one thing again and again: “I do not want to spend 8 years just writing tickets and then realize I never actually became a strong engineer.” So he created urgency. After office, he used to stay and pick one production system and go deep into it. How does the API handle retries? Why is this database query slow? What happens if this service goes down? How do logs, metrics and traces actually help during an incident? He was not trying to look busy. He was trying to understand the system like an owner. Most people around him were waiting. Waiting for a better project. Waiting for a mentor. Waiting for promotion cycle. Waiting for someone to teach them distributed systems. He did the opposite. He started taking small ugly problems that mattered - seriously. One day he fixed a memory leak. Another day he improved an API latency. Another day he wrote a proper postmortem after an incident. Another day he redesigned a retry flow so customers would not get duplicate orders. At that time, nobody clapped. No viral LinkedIn post. No big title. No special attention. But his brain slowly started believing: “Maybe I can actually become that engineer.” That is what urgency does. It makes your dream feel like a real project, not some fantasy you keep postponing. Today he is a Staff Engineer at a very good product based company. And honestly, it did not happen because he was some 10x genius. It happened because he started behaving like a senior engineer before anyone gave him the title. Most engineers want seniority. Very few create urgency. Urgency compounds. One extra debug session. One extra design doc. One extra deep dive into Kafka, Postgres, caching, observability, deployments. Do this for 2-3 years and suddenly people start saying: “Bro became lucky.” No bro. He just stopped waiting for tomorrow.
Urgency is what makes your brain believe that your dreams are possible to achieve. Without it, your mind will keep pushing the work to a tomorrow that will never come.
6
62
627
57,316