Ujjwal M

cricket lover, analyst.

[Sai @saidotdev]

Claude:
You've used 90% of session limit

Me instantly:

[Suraj Sharma @suraj_sharma14]

If I had 6 months to become an Agentic AI Engineer.

I would do this.

Stage 1: Python and Async Foundations
asyncio, FastAPI, event-driven architecture, error handling, API integration patterns.

Stage 2: LLM Fundamentals for Agents
Context management, model routing, token economics, latency tradeoffs, failure modes.

Stage 3: Tool Calling and Structured Outputs
Pydantic validation, function calling schemas, error recovery, dynamic tool discovery.

Stage 4: Memory and State Management
Short-term buffers, long-term vector recall, context compression, cross-session sync.

Stage 5: Single Agent Workflows
ReAct loops, plan-and-execute, self-reflection, iteration limits, graceful degradation.

Stage 6: Multi-Agent Orchestration
LangGraph or CrewAI, supervisor patterns, message passing, conflict resolution, handoffs.

Stage 7: Human-in-the-Loop Systems
Uncertainty detection, approval gates, audit trails, resume logic, intervention points.

Stage 8: Evaluation and Quality Assurance
Automated eval harnesses, LLM-as-a-judge, regression testing, hallucination metrics.

Stage 9: Observability and Tracing
Distributed tracing, cost dashboards, latency monitoring, alerting, debug pipelines.

Stage 10: Security and Guardrails
Prompt injection defense, output filtering, PII redaction, sandboxed execution, compliance.

Stage 11: Production Deployment
vLLM or SGLang, Kubernetes scaling, CI/CD for agents, canary releases, rollback strategies.

Stage 12: Open Source and Portfolio
Ship autonomous agents publicly, write architecture docs, record demos, contribute to libs.

Most people stay stuck watching tutorials.

Builders get hired.

Bookmark it.

[Shefali @Shefali__J]

10 GitHub Repos to Learn Node.js🔥

Open this🧵
Bookmark for later🔖

[Suraj Sharma @suraj_sharma14]

CANCEL your weekend plans.

You NEED to:

• Build a RAG system that cites sources with page numbers
• Implement hybrid search (dense + sparse) for better retrieval
• Add reranking with cross-encoders for top-10 accuracy
• Set up chunking strategies (500 tokens, 50 overlap minimum)
• Build query expansion for better recall
• Add metadata filtering for scoped retrieval
• Implement citation grounding to prevent hallucinations
• Create an eval harness with 50+ golden test cases
• Track retrieval metrics: hit rate, MRR, NDCG
• Add fallback to web search when confidence is low
• Build query rewriting for ambiguous questions
• Implement parent document retrieval for context
• Add embedding caching to reduce latency 80%
• Use colbert or late interaction for better accuracy
• Build a RAG dashboard showing retrieval quality
• Test with adversarial queries that should return nothing
• Document your chunking strategy and why it works
• Benchmark against naive RAG and show improvement

You have way too much to do.

Bookmark & Repost.

[Wayne @waynoir]

How LLMs Are Actually Evaluated

Just read this and it's probably the clearest breakdown of LLM evaluation I've come across

It covers the 4 main methods people use to evaluate models in sequence,
> Multiple choice benchmarks like MMLU, testing knowledge recall across 57 subjects and 16k+ questions
> Verifiers, letting models answer freely then checking the final answer against ground truth, the backbone of math and code evals
> Leaderboards, ranking models via human pairwise preference votes using Elo or Bradley-Terry
> LLM as a judge, using a second model with a grading rubric to score quality, style and correctness
> Where each method breaks down and why no single benchmark tells the full story
> How combining all four gives you the real picture of a model's strengths and weaknesses

[KrunalSinh Sisodia @krunalbuilds]

Just finished reading System Design for the LLM Era cover to cover.

This isn’t another “learn prompt engineering” book. It’s written for engineers who want to build AI systems that actually survive production.

What stood out:
• Strong focus on engineering trade-offs over AI hype
• Excellent coverage of latency, caching, model routing, RAG, observability, and failure handling
• The case studies (AI IDE, adaptive learning, search, customer support) make the concepts much easier to apply in real-world architectures
• Plenty of practical patterns you can take into your own designs

Overall, it’s one of the better AI system design books I’ve read. If you already understand distributed systems and want to design production-grade AI applications, I highly recommend it.

You can check it out here: https://t.co/QpgWcopqJl

A big thank you to the @sheerinuzma for giving me the opportunity to review an advance copy. I genuinely enjoyed reading it.

[avrl ☘ @avrldotdev]

Someone wrote a banger article on how LLMs & KV caching work internally in detail!

Bonus: learn how to design a caching system to utilise LLM side KV caching for your agentic sessions to reduce costs.

[Wayne @waynoir]

link of this blog:
https://t.co/uhuZeiwr7i

[avrl ☘ @avrldotdev]

https://t.co/4q0XBsoXDa

[England's Barmy Army 🏴󠁧󠁢󠁥󠁮󠁧󠁿🎺 @TheBarmyArmy]

🤣🤣🤣

[Suraj Sharma @suraj_sharma14]

If I had 6 months to become a GenAI Engineer.

I'd do this.

Stage 1: Python and API Foundations
FastAPI, async, error handling, webhooks, REST/GraphQL, third-party SDKs.

Stage 2: LLM Fundamentals for Production
Tokens, context windows, model routing, embeddings, cost/latency tradeoffs, failure modes.

Stage 3: Prompt Engineering and Structured Outputs
System prompts, few-shot chains, Pydantic/JSON validation, prompt versioning, unit evals.

Stage 4: RAG and Knowledge Grounding
Chunking strategies, hybrid search, rerankers, vector DBs, metadata filtering, citation tracking.

Stage 5: AI Workflows and Orchestration
Tool calling, state machines, human-in-the-loop, retry logic, fallback chains, session memory.

Stage 6: Build Production-Ready Applications
Domain-specific copilots, automation pipelines, streaming UIs, graceful degradation, rate limiting.

Stage 7: Evaluation and Reliability
Accuracy scoring, hallucination detection, RAGAS/DeepEval, regression testing, A/B output validation.

Stage 8: AI Infrastructure and Optimization
vLLM, Ollama, quantization, KV caching, response streaming, token cost tracking, edge deployment.

Stage 9: Deployment and Observability
Docker, CI/CD, cloud hosting, distributed tracing, structured logging, alerting, canary releases.

Stage 10: AI Security and Guardrails
Input/output filtering, prompt injection defense, PII redaction, compliance checks, sandboxing.

Stage 11: Open Source and Portfolio
Ship end-to-end apps publicly, write architecture docs, record demo walkthroughs, publish eval reports.

Stage 12: Apply
GenAI Engineer, Applied AI Engineer, AI Integration Engineer, LLM Solutions, AI Product Developer roles.

Most people stay stuck watching tutorials.

Builders get hired.

(bookmark it)

[SumitM @SumitM_X]

API concepts that are discussed in interviews ,
don't skip these if you are a backend dev :

1. Idempotency: Know why PUT/DELETE are idempotent but POST isn’t. Helps avoid accidental double writes.

2. Pagination: Offset works until scale hits. Cursor/keyset is what you need for big data sets.

3. Versioning: URI vs Header vs Query param. There’s no one right way, just tradeoffs.

4. Rate limiting: Token bucket > naive fixed window if you care about fairness.

5. Error contracts: 400 (bad request) ≠ 422 (validation issue) ≠ 409 (conflict). Don’t just throw 500 everywhere.

6. Caching: ETag + Cache-Control save you from unnecessary DB load.

7. Security: JWTs expire for a reason. Don’t stuff user PII inside them.

8. N+1 Queries: Kill them early. Use batching or joins when returning nested resources.

9. Docs: OpenAPI/Swagger is not optional.

10. Consistency: Sometimes cached data is good enough.

[Silent Strength @SilentStrengtth]

Build More Muscle Naturally.
The Ultimate Vegetarian & Non-Vegetarian Protein Foods List. 💪

1.

[Khairallah AL-Awady @eng_khairallah1]

this is f*cking gold

How to build your first AI agent (Full guide)

if I had this a year ago, I would've shipped my first agent in a day instead of 2 weeks

in the right hands, this changes everything:

[Dhairya @dkare1009]

Start with this 3-hour course by Andrej Karpathy. 👇

It covers the complete LLM pipeline—from fundamentals to scaling.

What's inside:

⏱️ 00:00 — Introduction to LLMs
⏱️ 12:41 — LLM Training Pipeline
⏱️ 31:58 — LLM Tools & Plugins
⏱️ 41:14 — Transformer Architecture
⏱️ 2:19:02 — Scaling Large Language Models
If you're learning:
• AI Engineering
• LLMs
• Transformers
• Generative AI
This is one of the best free resources available.
📌 Bookmark it for later.
📖 Read the accompanying article for a deeper understanding.
What's the hardest part of learning LLMs—transformers, training, or scaling? 👇

#AI #LLM #MachineLearning #DeepLearning #GenerativeAI #AndrejKarpathy

[Suraj Sharma @suraj_sharma14]

If I had to master Building Production-Grade AI Agents.

I'd do this.

Stage 1: Local-First Development
Ollama, LM Studio, zero API costs, infinite testing, break things freely.

Stage 2: Structured Outputs + Validation
Pydantic schemas, JSON enforcement, retry loops, parse error handling.

Stage 3: Agent Orchestration Frameworks
LangGraph for stateful workflows, CrewAI for role-based swarms, AutoGen for conversations.

Stage 4: Tool Calling + Integration
Web search APIs, calculator tools, custom functions, dynamic tool registry, permission scoping.

Stage 5: Memory + State Management
Short-term buffers, long-term vector recall, context compression, cross-session sync.

Stage 6: RAG + Knowledge Grounding
Chunking strategies, hybrid search, reranking, citation tracking, confidence scoring.

Stage 7: Evaluation + Quality Gates
Golden datasets, DeepEval/RAGAS, LLM-as-a-judge, regression testing, quality thresholds.

Stage 8: Observability + Tracing
LangSmith/LangFuse, latency dashboards, token tracking, error alerts, debug in minutes.

Stage 9: Security + Guardrails
Prompt injection defense, PII redaction, input/output filtering, audit trails, compliance.

Stage 10: Cost Optimization + Routing
Model routing by complexity, token budgeting, prompt caching, cheap vs expensive models.

Stage 11: Human-in-the-Loop Systems
Uncertainty detection, approval gates, pause/resume logic, validated context, full audit trail.

Stage 12: Deployment + Production Scaling
Docker, Vercel/Render, CI/CD, canary releases, rollback strategies, 99.9% uptime patterns.

Most people stay stuck watching tutorials.

Builders get hired.

(save this)

follow @suraj_sharma14 for such useful content.

[Suraj Sharma @suraj_sharma14]

The 30-Day Agentic AI Builder Challenge.

A daily building schedule that gets you hired.

Day 1-5: Foundations :-
Day 1: Install Ollama + run llama3.2 locally
Day 2: Build a "Hello World" agent with LangGraph
Day 3: Add Pydantic for structured JSON outputs
Day 4: Implement max_iterations=5 safety limit
Day 5: Add logging to see every prompt/response
>> Milestone: Your first working agent (local, free)

Day 6-10: Core Skills :-
Day 6: Build a RAG agent with 3 document chunks
Day 7: Add "Think step-by-step" to all prompts
Day 8: Create a multi-turn conversation agent
Day 9: Implement "I don't know" fallback logic
Day 10: Test with 10 different queries, log results
>> Milestone: Agent that doesn't hallucinate

Day 11-15: Real Tools :-
Day 11: Add web search tool (Tavily API free tier)
Day 12: Build a calculator tool for math
Day 13: Create a tool registry with 3 tools
Day 14: Add tool selection logic to your agent
Day 15: Test tool calling with 5 different queries
>> Milestone: Agent that uses tools correctly

Day 16-20: Memory + State :-
Day 16: Add short-term memory (last 5 messages)
Day 17: Implement long-term memory with SQLite-vec
Day 18: Build cross-session recall
Day 19: Add context compression for long chats
Day 20: Test memory with 20-turn conversation
>> Milestone: Agent that remembers users

Day 21-25: Production Ready :-
Day 21: Add LangSmith tracing (free tier)
Day 22: Set up cost tracking per request
Day 23: Implement error handling + retries
Day 24: Add human-in-the-loop for expensive ops
Day 25: Deploy to Vercel/Render (free tier)
>> Milestone: Live agent at a real URL

Day 26-30: Portfolio + Ship :-
Day 26: Write architecture docs for your agent
Day 27: Record a 2-min demo video
Day 28: Publish code to GitHub with README
Day 29: Post on X/LinkedIn with #BuildInPublic
Day 30: Apply to 5 jobs with your project
>> Milestone: You're now a builder not a learner

Resources You'll Actually Use:

Setup:
• Ollama: https://t.co/wSBgsjf70F (local LLMs, free)
• LangGraph: https://t.co/Rck6k9jFbX
• Pydantic: https://t.co/HIkx4j042B

Tools:
• Tavily API: https://t.co/oUbaGBFczT (web search, free tier)
• SQLite-vec: https://t.co/7htWk4Y2DR (vector DB)
• LangSmith: https://t.co/T5hGjE9Bny (tracing, free tier)

Deployment:
• Vercel: https://t.co/7rMH9pOvXU (frontend, free)
• Render: https://t.co/GzSrbIAuWN (backend, free tier)

(Bookmark this)

happy building.

[JeetShekhawat @JeetShekhawat00]

Here are 5 high-protein breakfast

Eggs + Whole Wheat Toast
2–3 boiled or scrambled eggs
2 slices whole wheat toast
Protein: 18–25 g

Greek Yogurt Bowl
1 cup plain Greek yogurt
Berries or banana
A handful of nuts or seeds
Protein: 20–25 g

Oats with Milk and Peanut Butter
1 bowl oats cooked with milk
1 tablespoon peanut butter
Chia or flax seeds (optional)
Protein: 15–20 g

Paneer (Cottage Cheese) with Vegetables
100–150 g paneer
Tomato, cucumber, spinach, or peppers
Protein: 18–27 g

Protein Smoothie
Milk
1 banana
Greek yogurt or a scoop of protein powder
Peanut butter
Protein: 25–35 g

[Dr.Sayajirao Gaikwad @DietDrsayajirao]

⚠️ Zinc Deficiency Signs:
- Low immunity
- Hair thinning
- White spots on nails
- Low libido
- Fatigue and poor wound healing

✅ Best Natural Sources :
- Pumpkin seeds (1 tbsp = 2.5 mg)
- Cashews (1 oz = 1.6 mg)
- Chickpeas, lentils, paneer, eggs, oysters
- Dark chocolate (70–85% cacao = 2.9 mg/100g)

Optimal Range
Serum zinc: 80–120 µg/dL
Daily requirement :
👉Men: 11 mg/day
👉Women: 8 mg/day
👉Athletes & diabetics often need up to 15–20 mg/day

[Barbara Oneill @BarbaraOneillAU]

FOODS TO EAT INSTEAD OF TAKING SUPPLEMENTS: 💊❌ ➜ 🍌🌶️🍄🍫🍠🥜

1. Zinc - Pumpkin seeds, chickpeas, cashews.
2. Calcium - Almonds, kale, sesame seeds.
3. Magnesium - Bananas, dark chocolate, spinach.
4. Iron - Spinach, lentils, quinoa.
5. Vitamin C - peppers. Oranges, strawberries.
6. Vitamin D - cereals. Mushrooms, egg yolks.
7. Omega-3-Walnuts, flaxseeds, chia seeds.
8. Vitamin A - Sweet potatoes, carrots, apricots.
9. Potassium - Avocados, bananas, potatoes.
10. Vitamin E - hazelnuts.