Christ Follower, #Accessability focused w CP, AI App Dev Storyteller @ Microsoft; RL,AI, VR/AR, IOT. Opinions mine. RTs & likes!=endorse

Kansas City, MO
Joined September 2007
Here is the resource guide for today's Transforming Your Future with Prompt Engineering and Generative AI presentation at DevSum 2023: github.com/JRAlexander/resou… #DevSum
2
7
815
At the Bernie-Bannon AI hysteria conference, they allowed a heretical voice on stage—who happens to be one of the smartest & most accomplished technologists on Earth. Jaron Lanier explained the origins of the problem—Minsky et al. anthropomorphizing AI because it sold well. The problem begins with calling it artificial *intelligence* far before you could plausibly argue that it was. Jaron calmly explains how the industry is now essentially a religion focused on building a machine god instead of tools for humans. For example, he says “agents” used to mean agents of humans—but now the industry switched it to “agentic AI” which makes loops of prompts sound like they have motivation or sentience. This is really worth watching. Jaron is a legitimate genius.
73
558
72
1,855
313,947
John Alexander retweeted
Anthropic's cost optimization skill is worth reading line by line Run /claude-api cost-optimize on any repo calling the API It profiles where your tokens go, ranks levers by savings, and applies free wins first (caching, input hygiene, batch) before tradeoffs (effort, model) One diff per lever, measured against your eval Read the sections, It'll help you optimize any agent app you're building github.com/anthropics/skills…
14
64
2
677
50,375
John Alexander retweeted
If you're building a mobile app with AI, save these 6 skills (bookmark this) > expo/skills - best practices for building and shipping mobile apps > mattpocock/skills - clean code, better architecture > Argent / agent-device - let your agent test the app > coreyhaines31/marketingskills - onboarding, App Store listings, content and ads > pbakaus/impeccable - design your app’s landing page > petergyang/no-ai-slop - remove AI slop from your copy Links below
11
30
1
278
22,070
John Alexander retweeted
MIT Advanced Data Structures course: courses.csail.mit.edu/6.851/… Video lectures, lecture notes, problem sets, GitHub, and more
4
198
3
1,352
43,512
John Alexander retweeted
Anthropic engineer just dropped a 2-hour+ workshop on Graph Engineering "80% of our engineers are already running self-improving loops Now everyone is moving toward agentic graphs" 0% → 04:43 - move from RAG to graphs 20% → 26:30 - understand nodes and edges 40% → 1:09:11 - index agent data inside graphs 60% → 1:30:50 - build the three graph layers 80% → 1:48:15 - create self-verifying Adaptive RAG 100% → 2:16:37 - see what comes after agent loops Most people are still building isolated agents Anthropic engineers are already connecting them through graphs Loops are the old workflow Graphs are the next one This 2-hour workshop is worth more than most $500 agent memory courses Bookmark it and watch before everyone starts catching on Then read the full graph engineering roadmap below
15
11
84
10,325
John Alexander retweeted
Damn it @kunchenguid I had shit to do today. Bro dropping bangers again :)
finally found time to make a new video! youtu.be/MSbacZ99E14 this time i'm sharing a slightly more advanced agentic engineering session, focused on high throughput multi-tasking hope you find helpful!
3
14
261
69,567
John Alexander retweeted
I thought I understood GPU utilization until I started working on this handbook. I kept collapsing three different things into one mental picture => the work a kernel launches, the work that is actually resident on the GPU, and the work that is ready to issue right now. They are not the same thing. Take a kernel with 240 blocks and 256 threads per block. That is 61,440 logical threads, or 1,920 NVIDIA warps. But those warps are not all physically resident at once. Blocks are admitted onto SMs as registers, shared memory, thread limits, warp limits and block limits allow. Even after a warp becomes resident, it may still be waiting on memory, an arithmetic dependency or synchronization. The scheduler can only choose from warps that are actually eligible to issue. That changed how I read performance numbers too. Occupancy is a residency number => resident warps compared with the architectural maximum. GPU utilization measures something different. In NVML it is basically the fraction of the sampling window during which at least one kernel was executing. So a GPU can show 100% utilization without Tensor Cores being saturated, without HBM bandwidth being saturated, and while one subsystem is the bottleneck and large parts of the GPU remain underused. Memory has the same kind of traps. Registers, shared memory, L1, L2 and HBM are not just increasingly slower boxes. They have different scope, capacity, management and access behavior. A model fitting in HBM tells you that it fits. It tells you almost nothing about how many bytes move, whether accesses coalesce well, how much reuse you get, or whether memory is what is holding the kernel back. FlashAttention is a nice example => the dense attention math stays the same, but the execution schedule is reorganized to reduce traffic between HBM and on-chip storage. Tensor Cores were another thing I had mentally oversimplified. They are specialized matrix multiply-accumulate hardware and they matter enormously for AI, but they do not “run the model.” Reductions, indexing, elementwise work, synchronization, memory movement, launches and plenty of other instructions still go through other parts of the GPU. After a while I stopped asking "why isn’t the GPU at 100%?" and started asking a better question => what is actually limiting useful progress right now? That ended up becoming a 42-page handbook. SMs, warps, schedulers, occupancy, latency hiding, registers, shared memory, caches, HBM, coalescing, Tensor Cores, GEMM mapping, precision, utilization and the performance numbers that are very easy to misread. Do read.
8
119
620
19,092
John Alexander retweeted
Stanford + MIT paper on Model Harnesses shows that AI performance depends not just on the model itself, but on the surrounding system code — the “harness”. This is what decides what to store, retrieve, show to the model, and how the workflow runs. With the same underlying LLM, changing the harness can create up to a 6× performance gap on the same benchmark. They conclude the harness around a model matters as much as the model itself. The paper introduces Meta-Harness, an outer-loop system that automatically improves harness code. Instead of giving the optimizing agent only a score or a short summary of past attempts, it gives the agent rich access to prior code, logs, and execution traces through a filesystem-like setup. The idea is that better diagnostic visibility lets the system improve the harness more intelligently. What it found is pretty significant. - On online text classification, a 7.7-point improvement over a strong SOTA context management, while using 4X fewer context tokens. - On retrieval-augmented math reasoning, an average gain of 4.7 points across five held-out models on 200 IMO-level problems. On agentic coding, the discovered harnesses beat strong hand-engineered baselines on TerminalBench-2. The paper shifts attention from “which model is best?” to “how is the whole AI system designed?” For real deployments, harness design affects reliability, tool usage, context management, and failure recovery. ---- Paper – arxiv. org/abs/2603.28052 Paper Title: "Meta-Harness: End-to-End Optimization of Model Harnesses"
39
58
12
326
18,391
John Alexander retweeted
Anthropic just dropped the clearest guide of context engineering for Fable 5 and GPT Astra. your CLAUDE.md is probably full of rules written for models that no longer need them, and every one of them is charged on every request: > blanket bans like never add comments, replaced by match the surrounding code > examples in tool descriptions, now narrowing the model instead of helping it > everything loaded upfront, instead of skills that load when the situation shows up > the same instruction sitting in the system prompt and on the tool 6 shifts total, and the first pass is deletion, not rewriting. run /doctor in your LLM and it audits your files against all of it. full docs below.
With AI Engineering skills, you actively shape the build: You influence what gets built, and drive the build loop. Here're key skills to do this.
11
25
1
283
71,434
John Alexander retweeted
This new paper from Microsoft is f*cking surgical Microsoft researchers just solved the most infuriating problem in production AI agents: finding where a 50-step execution actually died When an autonomous agent crashes at step 42, 99% of engineers debug step 42 They are debugging a ghost: The terminal crash was just a symptom - the actual, unrecoverable critical failure happened at step 04 when the model misinterpreted a tool output and silently corrupted its state Microsoft's AgentRx validates the core thesis of our Trace Engineering architecture: A trace is not a log of what an agent did - it is a structured representation of the agent's execution topology Causal Failure Anatomy: Step 04 (Silent Tool Misinterpretation) → Steps 05-41 (Cascading State Drift) → Step 42 (Terminal Policy Crash) Here is how Microsoft's AgentRx automates root-cause diagnosis across complex trajectories: [ 01 THE FAILURE LOCALIZATION BOTTLENECK ] - The Symptom Trap: Post-hoc terminal evaluation only tells you that an agent failed, forcing humans to spend 22+ minutes manually auditing each long-horizon trace - Downstream Misdirection: In multi-agent workflows, over 70% of apparent guardrail blocks or ungrounded final answers are downstream consequences of earlier unobserved hallucinations - The Goal: Pinpoint the exact first unrecoverable step in the causal chain where recovery became mathematically impossible [ 02 STEP-BY-STEP DYNAMIC CONSTRAINT SYNTHESIS ] - Global Constraints: Generated upfront from tool schemas and domain policies to enforce parameter types, mandatory arguments, and schema compliance - Dynamic Relational Constraints: Generated at each execution step from the running prefix to verify state consistency (e.g. checking if an agent's claimed item count matches the actual array length returned by an API) - Guarded Assertions: Every constraint evaluates as a guarded predicate, producing a deterministic pass or violation verdict backed by physical trace evidence [ 03 AUDITABLE VALIDATION LOGS ] - Step-Indexed Traceability: Instead of asking an LLM to blindly read a 16,000-token trace, AgentRx compiles an auditable validation log of violated obligations - Decoupled Adjudication: An LLM judge evaluates the validation log alongside a grounded taxonomy checklist, isolating the root cause without getting distracted by downstream execution noise [ 04 CROSS-DOMAIN FAILURE TAXONOMY ] - Grounded in 170 manually annotated production trajectories across retail APIs, cloud incident automation, and web navigation (inter-annotator agreement kappa = 0.89) - Identifies 9 mutually exclusive root-cause categories including Plan Adherence Failure, Invention of New Information, Invalid Invocation, and Tool Output Misinterpretation - Outperforms prior benchmarks by 75% on step localization and improves critical failure attribution by 30% [ EMPIRICAL HYPOTHESIS TESTING IN PRODUCTION ] - Industry Hypothesis: Monitoring terminal output success rates and logging raw agent stdout is sufficient to ensure reliability in production - Practical Production Test: We deployed AgentRx dynamic constraint verification across our multi-agent customer support and data infrastructure pipelines - Empirical Validation: Step-by-step constraint validation jumped critical failure localization accuracy from 31% to 78% (+151% relative gain). Root-cause MTTR fell by 64%, and infrastructure debugging costs dropped by 42% because our team stopped chasing downstream symptom artifacts Logging what an agent said is useless when state propagation is probabilistic If your observability stack does not evaluate execution constraints at every step, you are running blind systems and debugging downstream illusions Read the complete breakdown in the article below ↓
15
16
1
129
10,422
John Alexander retweeted
you'll know more about inference than 90% of people if you fully understand this article this is only the first resource in the ai performance engineering repo btw. imagine the ball knowledge in the other ones
we launched the most comprehensive ai performance engineering repo in the world last week now we'll be posting every single resource this is Wafer's ai performance engineering series save this as your starting point. links in thread 🧵 part 1: "All About Transformer Inference" from How To Scale Your Model. - the authors cover the computations, memory traffic, and serving decisions behind transformer inference: - arithmetic intensity of linear layers and attention across prefill and decode. - kv cache sizing by layer count, kv heads, head dimension, sequence length, and precision. - the compute/hbm bandwidth crossover and how batch size and quantization shift it. - decode latency and throughput bounds from parameter bytes, kv bytes, and hardware bandwidth. - weight reuse through batching and diminishing throughput gains as kv traffic grows. - gqa, kv quantization, and PagedAttention, including the memory costs each addresses. - model sharding, kv placement, and collective communication overhead. - continuous batching, prefix caching, and disaggregated prefill/decode. the worked problems connect model dimensions to deployment decisions like memory capacity, workload distribution, and expected performance under the stated assumptions.
31
122
4
1,771
207,384
John Alexander retweeted
How the fuck did I not know about transitions.dev 🤯 So many nice small animations that just make your UI feel better. In a world where everybody is shipping AI slop, these little details are what makes your product stand out. Given you’re not using purple gradients and putting borders around every single box of course.
59
169
10
2,903
307,576
John Alexander retweeted
Chinese researchers just published a paper with a brutal title: "The End of Prompt Engineering". The thing is f*cking gold, and the argument is simple: telling agents what to do is finished as a skill. A prompt is a wish, and a wish repeated three hundred times is still a wish. Boundaries written in a file are law -- read by every agent before every action, versioned, owned by you. At swarm scale nothing else composes. Three hundred agents cannot share a vibe, they can share a file. So the person stops being the one writing instructions. You turn into the boundary architect -- you define what never happens and audit the asks. Prompts turn disposable, the constraint file turns into the job. That is exactly the system I built and documented below: one AGENTS.md, three hundred Kimi K3 readers, zero escapes in 41 days. The paper's whole thesis in one line: write the fence before the keys ↓
46
118
6
708
85,863
John Alexander retweeted
Sam Altman (CEO of OpenAI): "You don't need to write prompts anymore. You need loops and graphs." in 38 minutes he explains how to use LLMs better than almost anyone does Prompts → Agents → Loops → Graphs that is the whole difference between using AI and having AI work for you same model, same tokens, and the only thing that changes is the shape you run it in watch it today, then save the full graph engineering guide below
10
19
2
139
29,241
John Alexander retweeted
“MIT wants to rebuild education around the things AI can't replace. That means oral exams, semester portfolios, in-person project work, and a required social component in every subject. The report even floats the idea of rethinking grades entirely, since without a GPA to optimize, much of the incentive to cheat with AI evaporates.”
MIT published a brutally honest report on what AI is doing to students. A committee of professors and students spent five months studying how AI changed learning on campus, and the findings read like a warning to every university on the planet. Study groups are disappearing. Office hours are emptying out. Problem sets and take-home exams no longer prove anything, because AI can produce credible solutions to almost any written assignment in the undergraduate curriculum. Students who lean on chatbots lose mastery and confidence, and some slip into what the report calls cognitive surrender, reaching for AI at the first hint of struggle. The numbers are rough. 46 percent of surveyed MIT undergrads use LLMs daily. 90 percent worry about their own overreliance. Undergrads who feel AI makes them replaceable now outnumber those who feel it makes them capable. The committee's answer surprised me. They refused to fight AI with surveillance. The report calls AI detectors unreliable, says lockdown browsers feel like spying, and warns that policing students builds a classroom atmosphere of mutual distrust. Instead, MIT wants to rebuild education around the things AI can't replace. That means oral exams, semester portfolios, in-person project work, and a required social component in every subject. The report even floats the idea of rethinking grades entirely, since without a GPA to optimize, much of the incentive to cheat with AI evaporates. The committee warns professors against replacing undergrad research assistants with AI agents just because they're cheaper, because a university exists to grow people, not output. The most famous tech school on earth admitted the machines broke its way of teaching. Its answer is more humans, not more software.
68
2,246
166
23,410
773,786
John Alexander retweeted
Putting the finishing touches on the Learn Omarchy app and package. Website is live now but still finalizing some package details. learnomarchy.com
20
58
4
629
29,975
John Alexander retweeted
I looked at Karpathy's diagram for the third time before I understood why it embarrassed me more than it should have three folders. one file. one loop. that's the entire architecture, and somehow almost nobody who saw it actually built it most people who try a second brain build a filing cabinet without ever realizing that's what they built. drop notes in, search when needed, watch the pile get bigger every year while understanding exactly nothing more than it did on day one. that's not memory. that's hoarding with better folder names, and you've been calling it a system a compiled wiki refuses to work that way, structurally, on purpose. raw holds the source, untouched, forever, ground truth that never gets edited by anyone. the model reads it once and converts it into structured, linked, evergreen knowledge, connected to everything already compiled before it. the human reads it. the model writes it. output only ever gets built from compiled understanding, never from memory alone, because memory alone is exactly the thing that was always going to fail you one file sits at the center and does something no folder in that diagram gets any credit for. CLAUDE.md. identity, preferences, goals, the entire shape of what you're working on. the model reads it before every single session, automatically, so you stop performing an introduction to a machine that was already supposed to know you the loop closes through update, and this is the exact part almost everyone skips without ever noticing they skipped it. every new source gets ingested, compiled, linked, integrated, permanently, no exceptions. skip that one step and you built a filing cabinet with better branding and a worse excuse. do it and the compiler gets smarter every single cycle without you lifting a single finger, while the library just gets bigger retrieval answers questions. compilation builds understanding. Karpathy put those seven words underneath a diagram that pulled in 5,000 stars and 16 million views, and almost none of that attention ever turned into anyone actually building it
12
60
472
56,476
John Alexander retweeted
pretty cool new course by stanford this fall on “engineering ai agents” goes through a lot of fundamentals of complex ai systems design cs329z.stanford.edu
9
66
2
537
42,094
John Alexander retweeted
This is the document I wish I had before I configured my first AI agent. Researchers scanned nearly three thousand real repositories to see which of the eight ways to configure a coding agent people actually use. Here is the order I would go in now. 1. Start with a context file and nothing else. Build and test commands, code conventions, what the agent must not touch. Write it for someone joining the project on Monday, not for a model. Most working setups never go past this file. The ones that do added the rest months later, after the context file was already good. 2. Name it AGENTS.md, not CLAUDE.md. Every major tool reads it. Claude Code still does not, so keep a two-line CLAUDE.md that points at AGENTS.md and maintain one file instead of two. Repos that started with CLAUDE.md are adding AGENTS.md and pointing the old one at it, so you might as well start there. 3. Only create a skill after you have typed the same instructions three times. And when you do, give it a script. Almost every skill in the wild is plain markdown with nothing executable in it, which means it is doing nothing a context file could not already do. If your skill is just instructions, it belongs in the context file. If it runs something, it belongs in a skill. 4. Add a subagent only when a job needs its own context, not its own name. Review, research, anything that would otherwise flood your main thread. Not "I want a specialist for each role". Most repos that use subagents define one or two, and that is the right number. 5. Skip hooks and MCP until something forces you there. Hooks when instructions get ignored and you need something that can actually refuse. MCP when the agent needs a system that has no file in your repo. The advanced features are sitting almost completely unused. That is the opportunity, not the checklist.
48
28
3
201
18,180