Mahesh Chulet

Building RAG, multi-agent systems, and MCPs is not demanding today, as these can be built using AI. Inference engineering, neural networks, time-series analysis, LLM research, and GPU kernels are worth investing in. At a higher level anyone can build anything, but lower-level engineering requires command of the basics. The more we normalize software, the more we must learn low-level engineering. At some point, business, communication, and end-to-end delivery on a tight timeline matter. That's what we call a high-agency person.

Working with agents all day is more tiring than writing code ever was, and we must admit it. Typing wasn't that tiring, you knew what you wanted, your hands did it, your head and thoughts wandered a bit. My days now are 3-4 agents running all the time, and each one stops every few minutes with a question. Approve this command? Option A or B? This test fails, should I change the test? Should I continuue? Each one is a an actual small decision, but each one needs the full context of a codebase and new code I didn't write line by line. By 6PM I'm done, not because I wrote a lot, but because I decided a lot. For a while I thought my limit was tokens, then the weekly usage limit, but turns out it wasn't. My limit is how many good decisions I can make before I start approving everything just to make the questions stop. How many agents do you run in parallel and for how long before your own answers get worse?

If I had to become an Applied AI / Applied LLM Engineer. I’d do this. Stage 1: LLM Foundations & API Mastery - Learn: Token math, context windows, sampling parameters (temperature, top-p), streaming (SSE), cost-per-call arithmetic, retry/backoff patterns. - Practice: Build a CLI tool that calls 3 different providers (OpenAI, Anthropic, Google), streams responses and prints exact cost and latency per call. - Why: You cannot optimize what you cannot measure. Every applied decision starts with token economics. Stage 2: Context Engineering (Beyond Prompting) - Learn: Dynamic context assembly, few-shot formatting, system prompt architecture, token budgeting, context compression. - Practice: Build a context assembler that dynamically allocates tokens between instructions, examples, memory and retrieved docs based on request type. - Why: Prompt engineering is table stakes. Context engineering is what separates working demos from production systems. Stage 3: Structured Outputs & Function Calling - Learn: JSON mode, Pydantic schema enforcement, function calling, retry-on-validation-failure, grammar-constrained decoding. - Practice: Build a data extraction tool that converts messy invoices into strictly typed Pydantic objects with automatic retry on schema violations. - Why: Real products need deterministic data, not creative prose. Structured outputs are the bridge between LLMs and software. Stage 4: Production-Grade RAG - Learn: Chunking strategies, embedding models, hybrid search (BM25 + dense), reranking, metadata filtering, citation grounding. - Practice: Build a RAG system over 1,000 documents with page-number citations and an eval harness measuring hit rate and faithfulness. - Why: RAG is still the default architecture for enterprise AI. But naive RAG fails retrieval quality is everything. Stage 5: Fine-Tuning & Model Adaptation - Learn: SFT vs PEFT, LoRA/QLoRA, dataset preparation, when to fine-tune vs prompt vs RAG, overfitting detection. - Practice: Fine-tune a 7B model with QLoRA to match your company's tone, then benchmark it against a prompted frontier model. - Why: Knowing WHEN to fine-tune (and when not to) is the mark of a senior applied engineer. Stage 6: Evals & Quality Assurance - Learn: Golden datasets, LLM-as-a-judge, precision/recall for generation, regression testing, CI eval gates. - Practice: Build an eval harness with 100 golden cases that runs on every prompt change and blocks deploys on score regression. - Why: Without evals, every model swap or prompt edit is a gamble. Evals turn vibes into engineering. Stage 7: Practical Agent Workflows - Learn: Tool use patterns, ReAct loops, plan-and-execute, iteration limits, human-in-the-loop checkpoints. - Practice: Build a customer support agent that classifies tickets, queries the CRM via tools, and escalates to a human when confidence is low. - Why: Agents fail without guardrails. Applied engineers know how to constrain autonomy to make it reliable. Stage 8: Production Deployment & UX - Learn: FastAPI serving, streaming UX, optimistic UI, semantic caching, model fallbacks, rate limiting, session management. - Practice: Deploy a chat app with streaming, sub-second perceived latency via optimistic UI and automatic fallback when the primary API fails. - Why: Users don't care about your model. They care about speed, reliability and whether it feels alive. Stage 9: Observability & Cost Attribution - Learn: LangSmith/Langfuse tracing, token attribution, latency monitoring, error tracking, cost dashboards per feature. - Practice: Build a dashboard showing cost-per-conversation, p95 latency and the exact traces behind every failed request. - Why: In production, the two questions are always "why did it fail?" and "how much is it costing?" You need answers for both. Bookmark and Repost!

Looking to connect with Founders building in👇 🤖 AI tools ⚙️ Automation 🛠️ Dev tools 📦 SaaS 💡 Side projects 🧠 Software developers If that’s you, say Hey! and drop in your URL below I would love to connect with you and see what you’re building.

Vibecoding is insane. You can build an app in a weekend. And still make $0. Because the hard part was never the code. It was: • finding a problem people actually pay to solve • getting the first 10 users • charging money and not apologizing for it • talking to customers instead of adding features • sticking with it after launch day goes quiet AI made building 10x easier. It made standing out 10x harder. When everyone can ship, shipping isn't the advantage anymore. Distribution is. Stop asking "what can I build?" Start asking "who will pay for this?"

If you’re starting out in 2026 don’t start a SaaS. Start an AI-enhanced productized service. Something worth $100k that you offer for $10k. - SEO optimization - Security auditing - Platform migration, etc Make $1 million doing that. Then build the SaaS around it. MOAT.

If you want Claude Code to work like a real senior dev, install these 5 free plugins: 1.) Agent Skills Reusable playbooks, so it follows proven workflows instead of guessing. 2.) Context7 Up-to-date library docs, so it stops writing outdated code. 3.) Graphify Turns your codebase into a knowledge graph, so it understands how everything connects before it touches anything. 4.) 21st MCP Builds polished UI components from a prompt, so your frontend stops looking AI-made. 5.) Strix An open-source AI pentester that finds real vulnerabilities in your app and fixes them. Junior devs write code. Senior devs understand, design and secure it. Bookmark this for your next build.

Startup ideas I'm giving away for free. I don't have time to build them. If you do, take them. 1) "Secret rot" scanner for AI startups Watches .env / CI / vendor keys after every deploy. Pings Slack the second a key leaves the repo. October just proved this is not optional. 2) Marketplace trust score for AI extensions Cursor / VS Code / MCP servers get a live "last audited / who signed / blast radius" badge. One bad extension nuked trust for 11 hours. Sell trust. 3) Vibecode → first 10 paying users Not another "build an app" tool. A product that forces: who pays, where they hang out, first outreach scripts, Stripe live in day 1. Building is free. Getting paid is the product. 4) Eval gym for agent founders Drop your agent. Get a failing task suite, regression board and a public score. Investors already ask "show me evals." Most teams still demo vibes. 5) AI invoice that explains itself Every LLM bill line mapped to: which feature, which user, which prompt. CFOs will pay. Engineers will finally stop guessing. 6) Co-founder match on shipped artifacts Not LinkedIn bios. Match on GitHub, eval harnesses and the last thing you actually launched. I won't build these. Reply with the number you'd steal first. I'll roast your version if you ship.

As an AI Security Engineer, you must build these projects. Systems that prove you can secure, cage & audit when autonomous agents touch your stack. 1.) Crescendo Attack Fuzzer Build: A multi-turn stateful harness that dynamically adapts payloads to groom context windows and bypass commercial system prompts. Why: Single-shot "ignore instructions" injections are dead. Modern attacks require stateful, multi-turn grooming. 2.) Sandboxed MCP Proxy Build: A JSON-RPC middleware that intercepts Model Context Protocol tool calls, validates parameters via Pydantic and blocks "confused deputy" privilege escalations. Why: Tool poisoning is the SQL Injection of the Agentic Era. Agents are only as secure as the tools they call. 3.) Inter-Agent Sanitization Bus Build: A message broker that strips hidden markdown and malicious instructions between Agent A and Agent B in a multi-agent swarm. Why: Swarms create internal trust boundaries. Agent A can be tricked into hijacking Agent B's tools via cross-agent injection. 4.) PII UUID-Swapping Gateway Build: A pre-flight proxy using NER to swap SSNs and credit cards for deterministic UUIDs before the LLM sees them, restoring them post-generation. Why: Zero-trust compliance demands that raw customer PII never touches a third-party frontier API. 5.) RAG Citation & Poison Detector Build: A pipeline that cross-references LLM claims against exact vector DB chunk hashes to detect shadow-context injection and citation spoofing. Why: If an attacker slips a poisoned document into your knowledge base, they own every answer the AI generates. 6.) CFG Output Caging Layer Build: Middleware enforcing Context-Free Grammar (CFG) decoding to physically block the generation of executable code, markdown links or unauthorized schemas. Why: System prompts are suggestions. Grammar constraints are physics. You must enforce security at the token-decoding level. 7.) Delegated Agent OAuth Broker Build: An auth service issuing time-limited, strictly scoped JWTs to agents so they can act on a user's behalf without holding raw passwords. Why: Agents need hands to do work, but they should never hold the master keys to the enterprise. 8.) PyRIT CI/CD Security Gate Build: A GitHub Action running 1,000 adversarial payloads via Microsoft PyRIT on every PR, blocking merges if the jailbreak rate exceeds 1%. Why: Manual red teaming doesn't scale. You need automated, continuous adversarial fuzzing integrated into your deployment pipeline. 9.) Semantic API Rate-Limiter Build: A gateway calculating embedding similarity of incoming requests to detect and block scraping bots trying to extract your model's weights. Why: Your fine-tuned weights are your IP. Competitors will try to distill your model through the public API. 10.) Computer-Use Pixel Auditor Build: A vision pipeline that scans screenshots for adversarial invisible UI elements and Set-of-Mark spoofing before a GUI agent clicks. Why: Screen-hijacking and pixel manipulation are the new privilege escalation vectors for Computer Use agents. 11.) Vector DB Sleeper-Agent Scrubber Build: An anomaly detector scanning episodic memory and vector stores for delayed-trigger payloads and semantic backdoors. Why: Long-term memory is a persistent attack vector. A poisoned memory bank will trigger exploits weeks after ingestion. 12.) Cryptographic Trajectory Ledger Build: An append-only, hash-chained audit log recording the exact prompt, retrieved context, tool calls and state mutations for every agent action. Why: When an agent makes a mistake that causes financial damage, the enterprise needs cryptographic proof of exactly why it happened. 13.) AI Supply-Chain SBOM Scanner Build: A tool auditing "vibe-coded" outputs and MCP server dependencies for hallucinated packages, typosquatting and backdoors. Why: AI-generated code and dynamic tool discovery create massive, unvetted supply chain risks. Bookmark & Repost.

Let’s connect! I am working a 9-5 while building some side projects. What are you working on, reply with your project