Shouda Wang

𝗧𝗵𝗲 𝗯𝗲𝘀𝘁 𝗔𝗜 𝗰𝗼𝗱𝗶𝗻𝗴 𝗹𝗲𝘀𝘀𝗼𝗻 𝗰𝗼𝘀𝘁 𝗼𝘂𝗿 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿 $𝟲𝟬𝟬 𝗮𝗻𝗱 𝗮 𝗺𝗮𝗿𝗿𝗶𝗮𝗴𝗲 𝗮𝗿𝗴𝘂𝗺𝗲𝗻𝘁. Our VP of Engineering, Xiaofan(James) Luan, was supposed to buy his wife a Dior bag for their anniversary.  Instead, he bought three Claude Code subscriptions and spent the holiday trying to cross-compile 2 million lines of C++. Every fix on one platform broke two others.  $600 later, the only output was "git reset --hard" — and a very cold dinner table.😂 "Make it compile on Windows" is a trap. The real goal was "compile everywhere without hacks" — no AI is going to figure that out for you at 2 am. What worked: constraints before code, review tests not code, bottom-up, one layer at a time. Same task, two days. Then he ran six parallel Claude sessions across three machines with git worktree. The bottleneck stopped being intelligence and started being how fast one person can alt-tab. AI solves exactly the problem you give it. Engineering is in knowing which one to give. His wife is still waiting for that bag. Full story: https://lnkd.in/gtsW_Wvk ——— Follow Milvus, created by Zilliz, for everything related to unstructured data

9

Save weeks of manual tuning for disaggregated inference with Microsoft Azure and NVIDIA. The collaboration delivered an automated, SLO-driven approach using the NVIDIA Dynamo suite on Azure Kubernetes Service (AKS): ⚡ NVIDIA Dynamo Profiler to simulate performance in 20-30 seconds ⚡ NVIDIA Dynamo Planner to provide LLM-aware runtime orchestration For one airline application run on Qwen3, this enabled: ✔️ Time-to-first-token under 500ms and inter-token latency under 30ms ✔️ 1.2 million tokens-per-second, powered by NVIDIA GB200 NVL72 systems Explore the deployment guide and hands-on example 🔗

3

Frustrated with GPU scarcity and fragmented infrastructure? Anyscale on AKS lets you manage and monitor Ray workloads across multiple regions and clouds with unified interface on a single dashboard: https://lnkd.in/eUdW4vRP

63

1 Comment

Why does an E3 level SWE at Meta make only ~190k/year, while an E8 level engineer makes over ~$2M/year, even though both engineers are ICs and spend the same time at work? I have spent the last 5 years at Meta as an IC. I joined with a little over 15 years of experience, and I’ve worked with many solid engineers in this time. Here is how I think about that compensation jump. 1. Same hours, completely different “unit of work” An E3’s unit of work is usually a task or a ticket. An E8’s unit of work is a multi year problem for the company. E3: “Implement this service, fix this bug, write this feature.” E8: “How do we cut infra cost by 20 percent across this product” or “How do we make this platform safe to scale to 10x users.” One person is paid to execute. The other is paid to decide what is worth executing in the first place. 2. Radius of impact E3 usually impacts a file, a service, maybe a small team. E8 shapes whole orgs and product lines. If an E3 ships something great, the impact is great but local. If an E8 ships the right platform, hundreds of engineers become faster and the company saves or earns millions every year. Comp tracks the area of the circle you influence. 3. Risk and downside protection At junior levels, mistakes are usually contained and reversible. At senior staff levels, a bad call can burn tens of millions or damage the brand. E8s are paid for judgment under ambiguity. They decide which bets the company should not make, which migrations can wait, which “shiny idea” is going to kill reliability. You pay more to people whose good judgment protects you from very expensive failures.  4. They scale themselves This can happen in a few ways. 1. Delegation with ownership They define the shape of the problem, then hand large pieces to other senior and mid level engineers while keeping the bar and direction clear. 2. Knowledge that travels They write RFCs, public comments, FAQs, wikis, internal posts. One answer helps hundreds of people who will face the same issue next quarter. 3. Tools over heroics Instead of unblocking people manually all day, they build tools, libraries or guardrails so others can unblock themselves. One well designed tool can save thousands of engineering hours every year. This is what “scaling yourself” actually looks like. The company pays for that multiplier.  5. Ownership of the “uncomfortable problems” Junior engineers usually work inside a well defined box. E8s take ownership between the boxes. They pick up problems that:  Span many teams and no one really “owns”  Require aligning leaders who disagree  Have product, infra, legal and security angles at the same time Most people avoid those because they are messy, political and slow. Very senior ICs lean into them. That is where a lot of value sits. Continued ↓

201

15 Comments

Etched just raised ~$500M in a major funding round (valued at ~$5B) to accelerate its custom AI silicon — a solid alternative to Nvidia-centric stacks. https://lnkd.in/dttxqJPJ

6

🚀 NVIDIA GPUs are the powerhouse behind AI breakthroughs from ChatGPT to autonomous vehicles driving faster, smarter, and scalable AI solutions worldwide. 🌐 #RecruitRidersTechnologies #AI #TechNews #Innovation #FutureIsNow #BrandChampions #WeAreRecruitRiders #SocialStars #EmployeeInfluencers

3

I just published Part 2 of my Multiplexed RBAC series. 👉 Multiplexed RBAC in .NET — Part 2: Atomic Distributed Cache with Redis, Lua & Safe Rotation Part 1 defined the execution contract. Part 2 tackles what most systems ignore: Distributed authorization correctness under concurrency. This is not about caching performance. It’s about: • Atomic in-flight coordination (Lua) • Lease alignment to prevent mid-request expiration • Overlap-safe key rotation (no validity gaps) • Deterministic fail-closed behavior • Memory fallback during transient Redis failures • TTL boundaries Authorization isn’t just roles and claims. It’s execution lifecycle integrity. Part 3 will connect this runtime to the HTTP pipeline: context handles, middleware invariants and TTL/session synchronization. Link in below👇 https://lnkd.in/gGZZXpNc #DistributedSystems   #SoftwareArchitecture   #RBAC   #DotNet   #Redis   #SystemDesign   #BackendEngineering

3

1 Comment

Microsoft Just Made 100B Parameter LLMs Run on Your Laptop. Who Governs Them? BitNet breaks the GPU barrier. 1.58 bit quantization. 100 billion parameters on a single CPU. No cloud. No API costs. Local inference at human reading speed. This is a genuine breakthrough for accessibility. But accessibility without governance is liability. Running locally solves the infrastructure problem. It does not solve the governance problem. A 100B parameter model on your laptop can still hallucinate with confidence. It can still produce biased outputs. It can still make decisions with no audit trail. It can still violate constitutional bounds you never defined. Privacy from cloud providers is not the same as privacy from the model itself. Local execution means your data stays on your device. It does not mean the model operates within governance constraints. The question is not where the model runs. The question is whether the model can prove it operated within bounds. YIN-GATEWAY solves this. YIN-GATEWAY is a cryptographic control plane that sits between any LLM and its users. Cloud model, local model, quantized model, full precision model. The deployment changes. The governance requirement does not. Layer 2 Admissibility Gates reject non-compliant queries before execution. The model never sees requests that violate policy. Layer 3 Constitutional Bounds verify every output before it reaches users. If the output would violate governance constraints, it does not proceed. Layer 14 SENTINEL Verification runs independent binary checkpoint validation. Pass or fail. No partial compliance. Layer 15 Human Override requires cryptographic signatures before high-risk outputs proceed. Not a checkbox. A mathematical proof that a human authorized this specific action. BitNet gives you a 100B parameter model on your CPU. YIN-GATEWAY gives you cryptographic proof that the model operated within constitutional bounds, regardless of where it runs. The hardware revolution is here. The governance layer was already built. https://lnkd.in/eb2EdEwR 32 USPTO applications. 3,057 claims. Any model. One governance layer. Enforced behavior. #BitNet #YINMazariArchitecture #YINGATEWAY #AIGovernance #CryptographicCompliance #Microsoft #LocalAI #LLM #PrivacyPreserving #ResponsibleAI #EdgeAI #CPUInference #OpenSource

4

1 Comment

Imagine you just joined Google as an SWE. It’s your first week, and you’re overthinking everything. You’re surrounded by world-class engineers, new systems, and an overwhelming urge not to mess up. The pressure to prove yourself is real, and so is the anxiety…so what should you do? Over the years, I’ve moved across orgs, teams, and sometimes, entire companies. Here’s exactly what I did (and still do) to ramp up faster and enjoy the process without letting anxiety win → Don’t let yourself stay stuck. If you’re blocked for more than 30 minutes, ask for help. Share what you’ve tried, show initiative, and intent. → Read way more code than you’re assigned. Dive into related modules, historic PRs, and old design docs. The context you gain helps you spot patterns and avoid mistakes. → Ask about the story behind the system. Find out why things are built a certain way, what’s failed before, and what’s on the roadmap. Understanding the “why” beats memorizing the “what.” → Volunteer for unglamorous work. Take ownership of tests, docs, or nagging integration bugs. This is where you quietly learn the most and build your internal network. → Offer help before you’re an expert. Chime in when you see questions, review PRs, or share a script. Even small contributions get you noticed for the right reasons. → Connect with skip-levels and cross-team leads. Set up short intros to learn about the broader vision and team priorities. You’ll spot opportunities to add value beyond your immediate tasks. → Document what you learn as you go. Share notes, update READMEs, or post quick how-tos in team channels. Your future self and your teammates will thank you. → Shadow someone during incidents or launches. Sit in on debugging sessions or war rooms, even if you’re just observing. You’ll see how senior folks think, react, and communicate under pressure. → Keep a running list of “how did that break?” moments. Every time you see a system fail or a hotfix go live, dig in. Reverse-engineering past problems is the fastest way to understand the architecture. → Show up with curiosity and intent, every day. Don’t just tick off JIRA tickets. Look for the bigger picture. People notice when you genuinely want to learn and contribute, not just “do your job.” Some orgs assign mentors, some don’t. Either way, these habits put you in the driver’s seat. Ramping up is less about brilliance, more about consistent intent. And the ones who learn this early end up leading teams later.

709

51 Comments

🦺 🛟 Agent Safety > Model Safety LLMs didn't break your app. Agents can. As we wire LLMs to tools, browsers, payments & code the risk shifts from bad text to bad actions. Top failure modes (seen in the wild & in papers): 🚩 Prompt/Content Injection -> Tool Misuse. Malicious web pages or data instruct agents to steal secrets or make unintended API calls. This is now a primary risk for browsing and MCP - style tool agents. 🚩 Over permissioned tools & long-lived tokens. Agents get "god mode" scopes. A single injection becomes account takeover or irreversible ops. Security notes for MCP emphasise least privilege and short-lived auth. 🚩 Unsafe web autonomy. Benchmarks show web agents will attempt harmful tasks unless constrained (posting misinformation, illicit sales, etc.). You must measure misuse not just assume guardrails. 🚩 Supply-chain & retrieval poisoning. Agents trust plugins, third-party tools & indexed data that an attacker can taint. OWASP’s newest GenAI Top 10 calls this out explicitly. 🚩 Process safety gaps. NIST's GenAI Profile (AI 600-1) warns that organizations ship agents without role clarity, human-in-the-loop or incident playbooks. ✅ Model safety reduces bad text. Agent safety prevents bad state. Treat the agent like a junior SRE - with narrow permissions, audited actions and clear escalation paths. If you're building agents, what's the one control you won't ship without? Also drop a comment if you'd like me to share a follow-up post on how to tackle each of these risks. #AgenticAI #AISafety #AIAgents #GenAI #CyberSecurity #MCP #OWASP #NIST #AITrust #ResponsibleAI #AIForBusiness

5

Why is Redis so fast and efficient even though it’s single-threaded? Redis achieves its incredible speed by keeping all data in memory, where access happens in nanoseconds. Its single-threaded event loop eliminates locks and context switching while efficiently managing thousands of concurrent requests through I/O multiplexing. Combined with highly optimized data structures like lists, sets, and hashes, and a lightweight RESP protocol that supports pipelining, Redis minimizes latency and maximizes throughput. Lua scripting adds another layer of power by allowing complex, multi-step operations to run atomically on the server, reducing network roundtrips and improving overall performance. Redis is a perfect example of how simplicity in design can lead to unmatched speed and scalability. #Redis #Performance #BackendDevelopment #Databases #Caching #Scalability #JavaDeveloper #Microservices #CodingJourney #FullStackDevelopment #TechCommunity #OpenToWork

2

If you want to become better at system design rounds, definitely read these 10 case studies by Neo Kim. I am 100% sure, they will make you smarter for your next interview.  1/ How Meta Achieves 99.99999999% Cache Consistency: → https://lnkd.in/e88kUZAm 2/ How Uber Computes ETA at Half a Million Requests per Second: → https://lnkd.in/eVKV2ePC 3/ How PayPal Was Able to Support a Billion Transactions per Day With Only 8 Virtual Machines: → https://lnkd.in/eqcb7MpP 4/ How YouTube Was Able to Support 2.49 Billion Users With MySQL: → https://lnkd.in/efmJw4Dx 5/ How WhatsApp Was Able to Support 50 Billion Messages a Day With Only 32 Engineers: → https://lnkd.in/gRqBgXfc 6/ How Uber Finds Nearby Drivers at 1 Million Requests per Second: → https://lnkd.in/eeqH9Hjh 7/ How Stripe Prevents Double Payment Using Idempotent API: → https://lnkd.in/erMkqwq4 8/ How Google Ads Was Able to Support 4.77 Billion Users With a SQL Database: → https://lnkd.in/efnSvwJp 9/ How Amazon S3 Achieves 99.999999999% Durability: → https://lnkd.in/eutGiK35 10/ How Slack Works: → https://lnkd.in/eATMDjrK

249

21 Comments