Femi

Human-Centered, Ethical Data & AI

[Jaydeep @_jaydeepkarale]

This repo is a goldmine if you are preparing forn Systemd Design Interviews

https://t.co/GDNl9D7DiR

[freeCodeCamp.org @freeCodeCamp]

Math isn't just about numbers - it's about finding complex patterns in our world.

And there are many ways that you can apply mathematical concepts in programming, beyond what you might've learned in school.

In this guide, Tiago discusses the architecture of math – and how you can use it in your code.

https://t.co/mH2DFQBGXy

[Hanako @hanakoxbt]

agents → tools → loops → graphs → autonomous systems

Google just put all five in one free course. most people stop after the first one.

2 hours 17 minutes, taught by a Developer Relations Engineer at Google Cloud. no signup, no paywall.

39:45 - build your first agent
56:10 - connect MCP tools
1:14:34 - four loop patterns for running it
1:23:01 - turn those loops into a graph
2:05:00 - wire the whole thing into one autonomous system

the progression is the point. one agent is a demo, an agent with tools does work.

loops let it keep going. graphs let several of them coordinate.

only the last step runs without you in the room.

most people are still tuning the prompt inside step one.

worth more than most paid agent bootcamps.

bookmark and watch it today, then read the full graph engineering breakdown below

[codila @0xCodila]

Google just released free 2-hour course on full Graph engineering: 1 prompt → 100 agents → loops → graphs from 0% to 100%:

10% → 17:44 - build your first agent
30% → 39:30 - Loop engineering: iterate, check, break
60% → 1:12:38 - Graph engineering
75% → 1:34:26 - agents that throttle themselves
100% → 1:55:05 - full graph for multi-agentic systems

everyone builds one agent and calls it done - this is the full system where agents wire themselves into a graph

watch the course, build the graph - then read the full architecture below ↓

[Kirk Borne @KirkDBorne]

"Domain-Specific Small Language Models: Efficient AI for local deployment" available at https://t.co/d09QJDV6m7 via @ManningBooks

[beamnxw ./ @beamnxw]

This paper is f*cking brilliant

A computer science paper establishes harness engineering as the primary determinant of AI agent reliability

The result: the ETCLOVG seven-layer architecture unifies execution sandboxes, tool protocols, context state, lifecycle graphs, observability, verifiers, and governance

The crazy part is how harness engineering boosts performance without changing the underlying model

Optimizing the execution harness alone increased SWE-bench coding benchmarks from 6.7% to 68.3%

Most developers try to fix agent failures by upgrading to larger LLMs

This framework shifts system reliability from model weights to deterministic harness architecture

Read the complete paper + article below

Bookmark it for future reference

[freeCodeCamp.org @freeCodeCamp]

A good prompt works for a single AI task. But multi-step workflows often need something more.

In this guide, Oyedele discusses prompt engineering vs loop engineering and when to use each approach.

You'll learn how to design AI loops with tools, guardrails, and human review, then build a practical PR review loop in Python.

https://t.co/D5xpzIe0sF

[Ahmad @TheAhmadOsman]

ATTENTION

The bible for running LLMs locally is now available online to read for FREE

Covers what to use on

- Laptop / edge / odd hardware
- Mac-first workflows
- Single RTX GPUs
- 2-4+ NVIDIA / CUDA GPUs
- General production serving
- Long-context / MoE / routing
- NVIDIA max performance
- Cluster orchestration

Software

- llama.cpp
- MLX / MLX-LM
- ExLlamaV2
- ExLlamaV3
- vLLM
- SGLang
- TensorRT-LLM
- NVIDIA Dynamo

You should read this, and if you cannot now then you most definitely wanna bookmark it for later

Local & Opensource AI FTW

[Neo Kim @systemdesignone]

I created a playbook to help you learn AI engineering.
It'll give you:

• Core concepts behind AI systems.
• Condensed notes to understand full-stack AI engineering.
• Must know techniques to build, deploy & scale AI apps.

(24 HOURS ONLY!!!)

1 Follow @systemdesignone [MUST]
2 Like & Retweet to get DM
3 Reply "Playbook"

Then I'll DM you the details.

[freeCodeCamp.org @freeCodeCamp]

Anthropic's Claude Certified Architect exam focuses on practical AI engineering, not just theory.

In this course, Andrew helps you prepare by building real-world agent workflows with Claude, MCP, and the Claude Agent SDK.

You'll learn about agent orchestration, tool design, prompt engineering, context management, and multi-agent architecture.

https://t.co/zA9wWu6puu

[codila @0xCodila]

Two Anthropic seniors just made Karpathy's loop 1000x better with "Graph Engineering" - dropped 11-page PDF

the shift: the agentic systems got 1000x better the moment you wired agents into a graph

here's the playbook in 6 steps:

step 1 → build one loop: generate, critique, revise - one self-review cycle beats a smarter model with none

step 2 → add tools: search, code execution, database - thinking without tools is hallucinating

step 3 → go parallel: spin up agents in separate worktrees - same repo, different branches, no conflicts

step 4 → add a graph: agents write findings as typed nodes and edges - not transcripts - every claim keeps its source

step 5 → ground your evaluator: it checks claims against graph edges, not vibes - "Triple not found" beats "seems off"

step 6 → the graph survives every session - your agents stop rebuilding context from scratch

the result: Karpathy ran 1 agent in 1 direction - this system runs 1,000 with shared memory - same model, it's the architecture

read this 11-page PDF and paste it into your Claude - you won't regret it

bookmark - then read the article on building graphs from scratch ↓

[codila @0xCodila]

Anthropic and Andrew Ng built an agent that uses 90% fewer tokens from scratch:

they dropped the entire book of Frankenstein into a prompt - 108,000 tokens asked one question

the input dropped from 108,000 tokens to 11

here's how:

step 1 → put everything that never changes at the top - tools, then system, then docs

step 2 → mark where the static part ends. everything above it gets cached

step 3 → one stray space breaks it - and you pay full price again

step 4 → the cache dies in 5 min - every read resets the clock

step 5 → cached tokens don't count against your rate limits. free headroom

most people never touch this - it pays for itself on day one

watch & bookmark - this 1-hour brilliant course ↓

[Femi @Olaw_femi]

@AiOs_public The reasoning is mostly useful to me as a debugging trace; finding the right balance between useful thinking and response time is still something I’m tuning.

[Femi @Olaw_femi]

I just published Separating Thought from Answer in a Local Reasoning Model https://t.co/urkBYKTX9w

[Femi @Olaw_femi]

@AiOs_public Good question. The post was mainly about separating and testing the output, rather than solving latency completely. I keep a token cap so it cannot think forever or use the whole budget before answering.

[Shraddha Bharuka @BharukaShraddha]

SYSTEM DESIGN — MASTER TREE 🌲

System Design
│
├── 01. Core Foundations
│ ├── Client-Server Architecture
│ ├── Monolith vs Microservices
│ ├── Stateless vs Stateful
│ ├── Horizontal vs Vertical Scaling
│ └── CAP Theorem
│
├── 02. Networking Layer
│ ├── DNS
│ ├── HTTP / HTTPS
│ ├── TCP vs UDP
│ ├── WebSockets
│ ├── Load Balancers
│ └── Reverse Proxies
│
├── 03. API Layer
│ ├── REST APIs
│ ├── GraphQL
│ ├── gRPC
│ ├── API Gateway
│ ├── Rate Limiting
│ └── Authentication
│
├── 04. Database Layer
│ ├── SQL
│ ├── NoSQL
│ ├── Indexing
│ ├── Replication
│ ├── Sharding
│ └── ACID Transactions
│
├── 05. Caching Layer
│ ├── Redis
│ ├── Memcached
│ ├── CDN
│ ├── Cache Invalidation
│ ├── Write-through Cache
│ └── Cache Eviction Policies
│
├── 06. Messaging Systems
│ ├── Kafka
│ ├── RabbitMQ
│ ├── Pub/Sub
│ ├── Event Streaming
│ ├── Async Processing
│ └── Queue Workers
│
├── 07. Reliability Layer
│ ├── High Availability
│ ├── Fault Tolerance
│ ├── Circuit Breakers
│ ├── Retries
│ ├── Disaster Recovery
│ └── Backpressure Handling
│
├── 08. Observability
│ ├── Logs
│ ├── Metrics
│ ├── Tracing
│ ├── Monitoring
│ ├── Alerting
│ └── SLA / SLO / SLI
│
├── 09. DevOps & Deployment
│ ├── Docker
│ ├── Kubernetes
│ ├── CI/CD
│ ├── Infrastructure as Code
│ ├── Blue-Green Deployment
│ └── Canary Releases
│
└── 10. Future Architectures
├── Serverless
├── Edge Computing
├── AI-Native Systems
├── Autonomous Infrastructure
└── Self-Healing Systems

Most developers learn frameworks.

The top 1% learn systems.

[Femi @Olaw_femi]

I just published empathySync: An AI Built to Let You Go https://t.co/Iaa1jFcIJH

[Hasan Toor @hasantoxr]

The 3 architectures every Al agent builder needs to know.

[烟花老师 @teach_fireworks]

Loop Engineering 精华文章汇总!

2026 年 Agent 开始聚焦在长任务后，重点慢慢变成了：

如何设计一个能够持续思考、执行、观察、验证和演进的循环系统？

从 Codex 到 Claude Code，从 OpenHands 到各种 Coding Agent。

业余项目和生产级系统之间最大的差距是Harness 工程，包括 Loop。

Agent 能不能持续工作几十分钟甚至几个小时？

能不能在失败后恢复？

能不能控制成本？

能不能知道什么时候停下来？

这些问题，最终都落到了 Loop 设计上。

📚 推荐阅读

1. Loop Engineering — Addy Osmani
https://t.co/bPvEN2wJIB

2. Loop Engineering — Firecrawl
https://t.co/38BnoAs2g1

3. What Is the AI Agent Loop? — Oracle
https://t.co/R17XAigxNf

4. Harness Engineering — OpenAI
https://t.co/N3qBMBaybB

5. Harness Engineering for Coding Agent Users — Martin Fowler
https://t.co/341m6RB95h

6. Agentic Loops: From ReAct to Loop Engineering
https://t.co/uZIFZCeOVi

7. Loop Engineering for AI Agents (Memory-First) — Mem0
https://t.co/IbhAUs9CkD

📄 推荐论文
1. Agentic Harness Engineering
https://t.co/D8CqREgstF

2. From Agent Loops to Structured Graphs
https://t.co/vq34blqjrw

🛠 推荐研究的开源项目
Codex CLI
https://t.co/8uwQryevJF

OpenHands
https://t.co/YMv6Fy9Jrp

PydanticAI
https://t.co/AgFNXxkiCR

OpenAI Agents SDK
https://t.co/xEnSYXRcVu

重点研究：
Loop 如何运行
Loop 如何停止
Loop 如何验证
Loop 如何恢复
Loop 如何调试

Prompt 决定 Agent 如何开始。
Context 决定 Agent 能看到什么。
Loop 决定 Agent 最终能走多远。

Loop Engineering：
Think
↓
Act
↓
Observe
↓
Verify
↓
Evolve
↓
Repeat

你设计循环。
Agent 在循环中持续改进。
每完成一次循环，系统都会比上一次更接近目标。
Agent 从来不缺 Loop。
缺的是 Loop 的工程学。

[Avi Chawla @_avichawla]

The ultimate Full-stack AI Engineering roadmap to go from 0 to 100.

Bookmark this.

This is the exact mapped-out path on what it actually takes to go from Beginner → full-stack AI engineer.

> Start with coding fundamentals.
> Learn Python, Bash, Git, and testing.
> Every strong AI engineer starts with fundamentals.

> Learn how to interact with models by understanding LLM APIs.
> This will teach you structured outputs, caching, system prompts, etc.

> APIs are great, but raw LLMs still need the latest info to be effective.
> Learn how LLMs are usually augmented with more info/patterns.
> This will teach you the basics of fine-tuning, RAG, prompt/context engineering, etc.

> Strong LLMs are useless without context. That’s where Retrieval techniques help.
> Learn about vector DBs, hybrid retrieval, indexing strategies, etc.

> Once retrieval is solid, move into RAG.
> Learn to build retrieval + generation pipelines, reranking, and multi-step retrieval using popular orchestration frameworks.

> Now, step into AI Agents, where AI moves from answering to acting.
> Learn memory, multi-agent systems, human-in-the-loop design, Agentic patterns, etc.

> Learn how to ship in production with Infrastructure.
> This will teach you CI/CD, containers, model routing, Kubernetes, and deployment at scale.

> Focus on observability & evaluation.
> Learn how to create eval datasets, LLM-as-a-judge, tracing, instrumentation, and continuous evaluation pipelines.

> Security is crucial.
> Learn how to implement guardrails, sandboxing, prompt injection defenses, and ethical guidelines.

> Finally, explore advanced workflows.
> This covers voice & vision agents, CLI agents, robotics, agent swarms, and self-refining AI systems.

This is the actual journey to becoming a full-stack AI Engineer and not just "use” AI, but designing full-stack AI systems that can survive in production.

If you need specific resources, I wrote a detailed article that provides a structured learning roadmap for AI engineers in 2026.

It covers prompting, RAG, fine-tuning, agents, MCP, evals, and inference, with guidance on what to prioritize and in what order.

Read it below.