Max He

Third piece in the AAD series is up. This one is about acceptance criteria (AC) and why treating them as a formal contract changes what you can diagnose when autonomous development breaks.  AC serve as the bridge between the spec and the environment in which the spec is compiled into a product. This is implicit in the first article, but after marinating on this for a few weeks, I felt like I should make it explicit.                                                                                                    The short version: most teams write AC the way you'd write them for a human. "Handle edge cases gracefully." "Performance should be acceptable under normal load." In AAD, those are  specification failures. An agent will do something when it reads that. It might even do something reasonable. But you've handed control over what "reasonable" looks like to the LLM, and you'll only find out whether you agree after you've burned the iteration cycle. In my experience, the first pass is ok, but it can quickly diverge and it takes a lot of time to get back to where you intended to go in the first place. One thing I keep coming back to is the diagnostic value of keeping the spec and the AC separate. My currently line of thinking leads me to this framing: The spec describes intent. The AC defines done. You need both. The Spec is the what and the why. The AC are the falsifiable tests that the intention was met. Keeping them separate creates a framework so they each get the attention they deserve as part of this new world. Building on the notion of falsifiability, there's also a section on the right mindset for writing AC. Just like with the best scientist/experimentalist, you should be writing AC from a lens that lets you confirm intention was not met, not that intention was met. It's a subtle but meaningful nuance. If you assume the agent is going to get it correct, you're biased to see the final product and assume it's correct. When you train yourself to focus on the ways the agent might get it wrong, you open up a whole new world on writing great AC. I think this applies to traditional development as well as AAD. Claude made a fancy doc for this one! But also, the full read is in the comments.

15

1 Comment

We live in an era where a single import torch can get a model up and running in minutes. But when things go wrong — collapsing loss functions, vanishing gradients — syntactic convenience isn’t enough. Progress still depends on a solid grasp of first principles. This is one of the most comprehensive resources I’ve come across: a textbook, video lectures, and Python implementations for every concept and chapter, with an excellent balance between theory and practical application. #MachineLearning #DeepLearning #AI #PyTorch #DataScience #MLTheory #FirstPrinciples #LearningResources #Engineering #AppliedAI https://lnkd.in/e_gysNCb

18

The end of human drivers? Tried Tesla Robotaxi in the Bay Area for the first time, 8.8 miles from Meta SF to Daly City station for $18. Unlike Waymo, Tesla’s Robotaxi can take the freeway. The ride was smooth, and the decision-making felt far closer to human than “bot-like.” What surprised me most: it’s just a regular Model Y. With the built-in rear screen, any Tesla could potentially be activated as a Robotaxi. That’s scalability at an entirely different level. Waymo might have an early lead, but Tesla’s vision-only approach gives it massive coverage and faster rollout potential. If this scales, Uber, Lyft, and even car ownership itself could be disrupted faster than expected. This is exactly why I quit my job to go all-in on ElasticDash We’re entering a new industrial revolution, the real question is: will you shape it, or be forced to adapt?

15

2 Comments

Every year in the U.S. alone, 40,000 lives are lost and 2.4 million people are injured in car accidents. Most of these tragedies come down to human error like distraction, fatigue, poor judgment. 𝐖𝐡𝐚𝐭 𝐢𝐟 𝐭𝐞𝐜𝐡𝐧𝐨𝐥𝐨𝐠𝐲 𝐜𝐨𝐮𝐥𝐝 𝐜𝐡𝐚𝐧𝐠𝐞 𝐭𝐡𝐚𝐭 𝐬𝐭𝐨𝐫𝐲? Waymo just released safety data after 56M+ fully driverless miles. The results are eye-opening: -> 85% fewer serious injuries vs human drivers -> 96% fewer intersection crashes (where many fatalities happen) -> 92% fewer pedestrian crashes -> 82% fewer cyclist/motorcycle crashes 𝐈𝐧 𝐨𝐭𝐡𝐞𝐫 𝐰𝐨𝐫𝐝𝐬: when you take the human out of the driver’s seat, the roads get dramatically safer. And adoption is accelerating fast. Waymo went from 10K weekly rides in 2023 → 250K rides in 2025. At this pace, they’ll likely hit 1M+ weekly rides by early 2026. But here’s the twist: the biggest barrier isn’t technology anymore. It’s policy, regulation, and public trust. Cities like NYC, Singapore, and Nashville are opening up, but many governments are still hesitating. So the real question isn’t “Is the tech ready?” It’s “𝐀𝐫𝐞 𝐰𝐞 𝐫𝐞𝐚𝐝𝐲 𝐭𝐨 𝐥𝐞𝐭 𝐠𝐨 𝐨𝐟 𝐭𝐡𝐞 𝐰𝐡𝐞𝐞𝐥?” (Image credit: Unsplash) #artificialintelligence #selfdriving #generativeai

6

I’ve been leaning on Claude Code a lot lately (I especially like the new Claude Opus 4.1) and this new short course from DeepLearning.AI crystalized a bunch of “do this, not that” habits for agentic coding. Claude Code: A Highly Agentic Coding Assistant (built with Anthropic) is clear, hands-on, and only 90 minutes or so long.  https://lnkd.in/guvsDnBg My big takeaway: Claude Code shines when you give it context + constraints and let it work in small, testable steps.  First reading the repo, then proposing a plan, then shipping diffs (not walls of code). The course walks through exactly that across three concrete projects (RAG chatbot, refactoring a notebook into a dashboard, and a Figma-to-web app build), plus GitHub hooks. If you are not already doing it, here were a few tips that can level up your usage: Use CLAUDE.md at the repo root (and even per-package in a monorepo) so Claude automatically pulls project norms, commands, and “gotchas” into context. It’s like a living, machine-readable onboarding doc. Create custom /slash commands by dropping prompt templates into .claude/commands.  This is great for repeatable workflows like “fix PR comments and push” or “triage Issue #1234.” Team-shareable via git. Headless mode for CI: run Claude Code non-interactively to label issues, do subjective linting (naming, clarity), or fan out codebase migrations. It’s an automation surface, not just a chat. MCP servers as power-ups: wire in tools (e.g., Puppeteer, Sentry) via .mcp.json so everyone on the repo gets the same agentic capabilities out of the box. Git + GitHub ergonomics: install gh and let Claude draft commit messages, open PRs, or resolve rebases—surprisingly effective when scoped to small diffs. Why I liked the course: it doesn’t just demo “AI writes code.” It teaches the workflow: have Claude summarize the codebase, set success criteria, ship incremental changes, and keep tests close. The GitHub hooks + notebook-to-dashboard refactor were especially practical. If you’re experimenting with agentic coding or trying to make it stick across a team, this is a crisp starting point. #AI #ClaudeCode #AgenticCoding #DeveloperExperience #MLOps #Productivity

18

1 Comment

Vision models usually stop at understanding. This one keeps going into interaction and physics. That’s a very different kind of perception. The video shows VIGA Vision as Inverse Graphics Agent, a system that reframes visual understanding as reconstructing the world that produced the image, not just predicting labels or dense maps. Technically, VIGA treats vision as program synthesis. Instead of a one-shot image To output pipeline, it runs an analysis-by-synthesis loop: proposes executable Blender Python code (geometry, camera, materials, lighting, physics) renders the scene compares render together input using photometric signals and VLM based feedback iteratively refines with a persistent scene memory This design unlocks several important properties: • Explicit world representation : the output is an editable, inspectable scene program, not a latent tensor • Error localization , failures are diagnosed at the level of camera pose, scale, materials, or physics • Compositional reasoning ,multi-step edits build on prior state instead of restarting from scratch • Physical consistency ,reconstructed scenes support interactions (collisions, gravity, motion) • Better generalization , operating in program space enables large gains on multi-step and compositional benchmarks On BlenderBench and BlenderGym, this approach significantly outperforms one-shot VLM baselines and memory-less agents , not because of bigger models, but because the representation itself is executable. The broader takeaway isn’t “Blender as a backend”. It’s the return of explicit, controllable world models, now combined with agentic reasoning. This direction feels tightly aligned with: Vision Language Action models Embodied AI and robotics Simulation-first learning Digital twins and dynamic world models Paper: Vision as Inverse Graphics Agent via Interleaved Multimodal Reasoning Curious whether inverse-graphics agents will become the default interface between perception and action , especially as we move beyond static scenes. #ComputerVision #InverseGraphics #EmbodiedAI #WorldModels #AgenticAI #Simulation #Robotics #3DVision #AIResearch #VLM #AI

15

1 Comment

Been trying out a semantic chunking strategy recently. The logic is to check if the max_sim between a new sentence and the current chunk is greater than the min_sim within the chunk. If so, merge; otherwise, create a new one. But in practice, I found that as soon as one irrelevant sentence gets into the chunk, the min_sim plummets, and then it pretty much stops creating new chunks. Also, just looking at max_sim can chain two unrelated topics together with just a few transitional sentences, which is a real headache. Performance-wise, the O(m²) complexity is just unusable. So, I changed my approach: for small chunks, I only use a max_sim threshold. Once the chunk gets larger (e.g., >5 sentences), I then bring in quantile-based constraints. This change really helped mitigate the chain-linking issue. For performance, you still have to use incremental calculations or approximate quantiles, or it's just too slow.

3