SS Vishnu

[Abhishek Singh @0xlelouch_]

Top 10 resources to learn observability (practical for people shipping + on-call):

1) Observability Engineering (Charity Majors et al.). How to think in unknown unknowns, not dashboards.

2) Site Reliability Engineering + The SRE Workbook (Google). SLOs, error budgets, and how alerting ties to user pain.

3) OpenTelemetry docs + semantic conventions. Learn context propagation, spans vs metrics, baggage, and naming that survives refactors.

4) Prometheus docs (recording rules + alerting). Teaches cardinality limits, rate() vs histogram_quantile(), and alert design.

5) Grafana Labs blog. Real writeups on dashboards, Loki, Tempo, and what breaks at scale.

6) Elastic Observability guide. Solid patterns for log parsing, field mapping, and avoiding expensive queries in prod.

7) Honeycomb blog + papers. Great for high-cardinality events and asking questions during incidents.

8) Brendan Gregg’s USE method + RED method posts. Simple checklists for hosts, services, and request paths.

9) Jepsen analyses (Aphyr). Not observability tooling, but forces you to instrument for correctness under failure.

10) Practice project: instrument a small service (HTTP + Postgres + queue). Add trace IDs end-to-end, histograms, structured logs, then chaos test: kill a dependency and verify you can answer what broke, where, and how many users saw it

[Thariq @trq212]

We removed ~80% of the Claude Code system prompt for our newest models, this is what we've learned about writing system prompts, skills and Claude.MDs for them. https://t.co/6DZwSrZjE9

[Tech with Mak @techNmak]

These engineering blogs have taught me more about AI system design than most courses I’ve gone through.

Here are 15 worth bookmarking:

[Kun Chen @kunchenguid]

many people asked me how to write CLAUDE.md or AGENTS.md, and i see lots of bad advice flying around

so i took some time to write down a guide in https://t.co/v9rrkWKEFr

tl;dr
- handwrite your user level AGENTS.md
- for project level ones, you don't write it. you train it like a neural net

i also open sourced my private solution "backpass" at https://t.co/DkM9b4TcZ0 - it samples your past agent sessions for a repo, distill key learnings and losses, synthesize them, and produce a gradient descent step as a proposal that you can review and apply to improve your AGENTS.md and project level skills

easiest way to run it is just "npx -y backpass" in your repo

hope it helps! please share with whoever you think can benefit from it

[Abhishek Singh @0xlelouch_]

Top 10 resources to learn backend engineering (practical for working devs):

1) Designing Data-Intensive Applications (Kleppmann)
Replication, partitions, indexes, transactions. Explains the tradeoffs behind most architecture debates.

2) Release It! (Nygard)
Real failure modes: timeouts, backpressure, circuit breakers, bulkheads. Helps you write code that survives prod.

3) Web Scalability for Startup Engineers (Virding)
Queues, caches, load balancers, capacity math. Fast read with a lot of useful rules of thumb.

4) PostgreSQL docs (esp. EXPLAIN, indexing, autovacuum)
Most backend latency is the DB. Learn to read query plans and tune the boring settings that matter.

5) Redis docs + https://t.co/WYSNIitmxk topics (eviction, persistence, clustering)
Cache stampedes, hot keys, memory limits, and why your cache can become your outage.

6) OpenTelemetry docs + instrument one service end-to-end
Traces, metrics, logs, context propagation. You will debug faster and argue less about what happened.

7) Cloud provider well-architected guidance (AWS/Azure/GCP)
Concrete checklists on IAM, networking, retries, quotas, multi-AZ. Good for avoiding expensive footguns.

8) Martin Fowler blog (and tagged architecture posts)
Strangler fig, transactional outbox, idempotency, evolutionary design. Patterns that show up in migrations.

9) Practice project: build a tiny payments API
Postgres ledger table, idempotency keys, retries, outbox to a queue, reconciliation job, audit log, p95 latency budget.

10) Practice project: operate it like a real service
Docker + CI, load test (k6), dashboards (Prometheus/Grafana), alerts on SLOs, chaos test killing the DB, write the runbook for on-call rotation

[Andrew Ng @AndrewYNg]

The most important skills in Building and Deploying AI Applications. https://t.co/IyWIKLIzeM

[Mohit Goyal (Harness arc) @ByteMohit]

CANCEL your weekend plans.

You NEED to:

• Master Context Engineering (it replaced Prompt Engineering)
• Build a custom MCP (Model Context Protocol) server from scratch
• Implement Trajectory Evals (grade the agent's steps not just the final answer)
• Add stateful persistence with Temporal dot io or LangGraph checkpoints
• Build inter-agent security (prevent Agent A from injecting Agent B)
• Track TTFT (Time to First Token) and ITL (Inter-Token Latency) not just total time
• Ship a local-first feature using MLX or WebLLM for zero-cost, private inference
• Build semantic caching with embedding similarity to kill 30% of your API bill
• Design graceful degradation chains (Opus fails → Sonnet → Local Llama → Cache)
• Implement async tool execution with webhooks for tasks that take >10 seconds
• Build a Data Flywheel that turns user thumbs-downs into tomorrow's golden dataset
• Add hard cost kill-switches per user and per tenant to prevent the $10k overnight bug
• Upgrade to Multi-Modal RAG (parse tables, charts and images not just plain text)
• Enforce typed state handoffs between agents (Pydantic models, never raw text)
• Set up Shadow Testing (route 5% of prod traffic to new prompts silently to compare)
• Implement Guardrails-as-Code (version control your safety rules like source code)
• Build a multi-tenant vector DB with strict row-level metadata filtering
• Write a public teardown of the hardest bug you fixed this week

You have way too much to do.

Bookmark & Repost.

[Abhishek Singh @0xlelouch_]

90% of Go in 2026 comes down to mastering these 10 concepts (the rest is arguing about frameworks):

1) Context everywhere
Deadlines and cancellation across HTTP, DB, and RPC; missing ctx is how you get stuck goroutines and mystery latency.

2) Concurrency with budgets
Goroutines are cheap until they’re not; cap with worker pools/semaphores and track p95 queue time, not just CPU.

3) Channels vs mutexes
Channels for ownership and pipelines, mutexes for shared state; mixing both without a clear rule breeds deadlocks.

4) Escape analysis and allocations
Know when you’re putting stuff on the heap; a single hot path allocating 1KB/request at 5k rps is 5MB/s of GC churn.

5) Interfaces and nil traps
Typed nil inside an interface still isn’t nil; it shows up as weird panic paths and broken error checks.

6) Error hygiene
Wrap with context, don’t log twice, and make retryable errors explicit; production is debugging by stack + message.

7) Tooling that pays rent
go test -race, go vet, staticcheck, fuzz, and pprof in CI; most outages are regressions these would’ve caught.

8) Debugging in prod
Learn pprof CPU/heap/block, goroutine dumps, and trace; knowing what a blocked goroutine looks like saves hours.

9) Observability, not printfs
OpenTelemetry traces + metrics + structured logs; always tag tenant, endpoint, status, and build SHA for bisects.

10) Security defaults
Disable http.DefaultTransport surprises, set timeouts, validate inputs, pin TLS settings, and audit deps; the common bug is trusting inbound JSON too much

[Puneet Patwari @system_monarch]

I cracked 5 Staff/Senior Eng. roles in 2025. Here's my full Senior SWE preparation roadmap for Google L5 / Meta E5 / Amazon L6 type roles.

These are roughly ₹70L to ₹1.3Cr+ total-comp roles in India depending on company, offer and stock.

If I were preparing again, this is how i'd do it.

[Abhishek Singh @0xlelouch_]

Asked: design Uber ride matching.

1) Clarify requirements
- Goals: match rider to a nearby driver, fast, fair, safe
- Latency: p95 match < 2s, pickup ETA accuracy matters more than perfect optimality
- Scale: city-level spikes (events, rain), tens of thousands of online drivers
- Constraints: cancellations, driver decline, surge, accessibility, pooling?

2) Core APIs + data model
- POST /rides (rider_id, pickup_latlng, dest_latlng, product)
- POST /drivers/{id}/location (latlng, heading, speed, availability)
- POST /rides/{id}/offer (driver_id) and driver accepts/declines
Tables:
- drivers(id, status, product_caps, last_seen)
- rides(id, rider_id, status, pickup, dest, created_at)
- offers(ride_id, driver_id, state, expires_at) idempotent keys everywhere

3) Architecture sketch
- Location ingestion service writes driver locations to in-memory geo index (Redis GEO, H3/S2 cells) with TTL
- Matching service: on ride request, query nearby cells, score candidates (ETA, acceptance rate, idle time, product)
- Offer workflow via queue (Kafka/PubSub): send offer, wait N seconds, next driver on timeout/decline
- Ride state as a small state machine stored in strongly consistent DB; cache for reads

4) Scaling decisions
- Partition by city + geo cell, keep hot state close (regional clusters)
- Backpressure: cap candidate set (ex: top 50 by distance) then compute ETA for top 10
- Precompute ETAs with routing service cache; degrade to distance-based if routing is slow
- Use streaming updates, but coalesce driver location writes (ex: 1 Hz) to avoid write storms

5) Tradeoffs to call out
- Consistency vs speed: geo index is eventually consistent; ride state transitions must be consistent
- Fairness vs efficiency: pure nearest driver can starve others; add rotation/idle-time weighting
- Global optimum vs local heuristic: Hungarian matching is too slow; greedy with constraints wins

6) Failure cases + mitigations
- Driver app flaps: TTL + last_seen, avoid offering to stale drivers
- Duplicate requests/offers: idempotency keys, dedupe by ride_id
- Queue delays: offer expiry, retry with jitter, circuit breaker to simpler matching
- Partial outages: fall back to cached geo index, degrade ETA accuracy, pause pooling

[Kaivalya Apte - The Geek Narrator @thegeeknarrator]

De-Complicate your life by 90%... https://t.co/pwuRTNR3tT

[Andrew Ng @AndrewYNg]

New: A map of the most important skills in AI Engineering. https://t.co/VVkn1Dqp1N

[Abhishek Singh @0xlelouch_]

Top 10 resources to learn technical writing for engineers (stuff that helps in PRDs, RFCs, runbooks, and postmortems):

1) Google Technical Writing Courses (free). Tight basics on structure, clarity, and editing, with exercises.

2) The Elements of Style (Strunk & White). Not modern, but it’ll cure 50% of rambling docs fast.

3) On Writing Well (Zinsser). Great for cutting fluff and writing for busy readers who skim.

4) Docs for Developers (Jared Bhatti et al.). Practical patterns for reference docs, tutorials, and troubleshooting sections.

5) Write the Docs (site + conference talks). Real doc problems: information architecture, doc debt, ownership models.

6) Microsoft Writing Style Guide. Concrete rules for voice, headings, UI terms, and consistency at scale.

7) Google Developer Documentation Style Guide. Good defaults for code samples, linking, warnings, and scannable pages.

8) Diátaxis Framework (docs structure). Helps stop mixing tutorial vs reference vs explanation in one messy page.

9) Grammarly or Vale + a style guide in the repo. Catch repeats, passive voice, long sentences during CI, like tests for prose.

10) Practice project: write 3 production-shaped docs
- an RFC for a breaking change (rollout plan + rollback)
- an on-call runbook (symptoms, checks, commands, dashboards)
- a postmortem (timeline, contributing factors, follow-ups with owners)

[Puneet Patwari @system_monarch]

If you want to become awesome at AI system design, save these 15 engineering blogs:

I picked recent technical breakdowns from companies building AI systems at scale.

[Puneet Patwari @system_monarch]

I have 12 years of experience and work as a Principal Engineer @Atlassian.

I’ve seen Concurrency scares junior engineers.
But Replication scares even senior ones.

Once you copy data to a second machine, every question you thought was settled reopens. Which copy is right. What a user sees after they hit save. What happens when the network splits in half.

These 20 concepts cover it. Save this thread.
Read till the end.

Your production incidents will get shorter.

[Puneet Patwari @system_monarch]

If you want to become Senior+ level at system design, save these 10 GitHub repos:

[Khairallah AL-Awady @eng_khairallah1]

this is f*cking gold

Andrej Karpathy joined Anthropic five weeks ago.

Two Anthropic seniors just made Karpathy's loop 1000x better with "Graph Engineering"

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

I dropped it into my setup. The very first response was different.

Not slightly different. Completely different.

Claude stopped giving generic answers and started working exactly the way I think.

Bookmark it before it gets lost in your feed.

Read it now, then check the article below.

[Mrinal @Hi_Mrinal]

as you all know I was on a run to gather more and more information on how S3 transitioned from its one consistency to another I got to find soo many great reads on its internals from different sources

here are few (all the links in the comments)

[Abhishek Singh @0xlelouch_]

Top 10 resources to learn backend engineering (practical for working devs):

1) Database Internals (Alex Petrov). LSM vs B-Tree, WAL, compaction. Helps when Postgres is slow and you need real levers.
2) PostgreSQL docs. EXPLAIN/ANALYZE, indexing, autovacuum, isolation levels. Most “backend scaling” is fixing queries.
3) High Performance Browser Networking (Ilya Grigorik). HTTP/2, TLS, connection reuse. You’ll stop guessing about latency.
4) gRPC + Protobuf docs. Contract evolution, deadlines, retries, streaming. Useful for service-to-service APIs that don’t melt.
5) OpenTelemetry docs + a weekend instrumenting one service. Traces + metrics + logs with a single request id beats dashboard tourism.
6) Site Reliability Engineering book. Error budgets, SLOs, incident process. The parts that matter when on-call gets noisy.
7) OWASP ASVS + Cheat Sheet Series. Practical security checks: auth, session, SSRF, injection, secrets handling.
8) Redis docs. Eviction policies, persistence, cluster behavior. Caches fail in specific, repeatable ways.
9) Build a toy URL shortener, then harden it: idempotency keys, rate limits, background jobs, migrations, p95 latency, chaos tests.
10) Read real postmortems (Stripe, Cloudflare, GitHub). Concrete failure modes: thundering herds, bad deploys, time drift, dependency outages

[Alex Lieberman @businessbarista]

Best explainer on Kimi K3 i've read.

It walks you through how the model works & the elegant innovation behind it:

- K3 is the biggest open model anyone has released: 2.8 trillion parameters total, though only 104 billion of them do the work on any given word.
- The problem Moonshot went after is memory. Normally a model keeps notes on every word it has read, and that pile grows with every token, which is why long conversations get slow and expensive.
- K3 mostly stops the memory pile from growing. Three out of every four layers use a new mechanism called Kimi Delta Attention, which keeps a fixed-size working memory and edits it as it goes, overwriting what's stale instead of hoarding everything. The fourth layer keeps a compressed record of each word so exact details are still recoverable when they matter.
- They proved this on a small model first. A 48B test version used up to 75% less memory and ran about 4× faster at long context, while matching or beating the conventional design on the benchmarks they reported.
- Training leaned hard on long jobs including coding, browsing, research, visual work, agent sessions running hundreds or thousands of tool calls in a row.
- 1 Million cached input tokens costs $0.30. An agent can pull the same repo, the same docs, the same tool definitions back into context over and over without the bill getting stupid. Moonshot credits that to the memory design working alongside their serving stack.
- The biggest takeaway: context window size is the main character, but what matters is what a model compresses, what it forgets, and how it gets exact information back.