Don't use any words the LLM suggests and ignore its praise — instead use it like a copyeditor to catch mechanical problems you'd miss on your own. The author argues this keeps your voice intact while making editing faster and less exhausting.

• LLM-generated phrases register as "output" rather than writing to readers, so you need to write the whole piece yourself first and reject any specific wording the model proposes, no matter how good it sounds.
• LLM encouragement will trick you into keeping bad first-draft impulses you'd normally cut during revision, which is where your actual voice comes from.
• LLMs excel at spotting tedious mechanical problems — overused words, passive voice, repetition, buried verbs — work that's exhausting to do manually but essential to good editing.

Open Code Review is an open-source CLI tool that uses LLMs to review code diffs and full files with higher precision than general-purpose AI agents while using 9x fewer tokens. It combines deterministic engineering (file selection, rule matching, positioning) with an agent for dynamic decisions, and has been validated across 200 real pull requests from 50 open-source projects.

• Achieves significantly higher precision and F1 scores than Claude Code with the same underlying model, consuming only ~1/9 of the tokens and completing reviews faster
• Uses hard constraints (precise file selection, smart bundling, fine-grained rule matching, external positioning modules) to eliminate common AI agent failures like incomplete coverage and position drift
• Built on production data from Alibaba's internal use across two years serving tens of thousands of developers and identifying millions of defects

Tencent released Hy4 preview, a large language model with 770B parameters and over 1M token context window, designed for coding, office work, and scientific research. The model outperformed competitors like GLM-5.3 and Kimi K3 in Tencent's internal evaluation and can be accessed free for two weeks through WorkBuddy and CodeBuddy.

• Hy4 preview scored 2.99/4.00 in Tencent's blind evaluation of 203 engineering tasks, beating GLM-5.3 (2.92) and Kimi K3 (2.94)
• The model participated in its own development, autonomously optimizing training methods and inference infrastructure, increasing throughput by 31.8% over baseline
• Pricing is competitive at $0.834 per million input tokens and $2.501 per million output tokens, with specialized optimization for game development and scientific research tasks

Meta open-sourced Muse Glimmer, a 30-billion-parameter model designed to run on consumer GPUs and laptops for local AI agent tasks like scheduling, coding, and tool use. The model uses quantization and speculative decoding to fit within 20-32GB of memory while maintaining speed for real-time interaction. It's available now under Apache 2.0 license with integrations for llama.cpp, MLX, and other frameworks.

• Meta open-sourced Muse Glimmer, a 30B-parameter agentic model quantized to under 20GB so it runs locally on consumer GPUs/laptops (24-32GB) while competing with Gemma 4-31B and Qwen 3.6-27B.
• Speculative decoding with a lightweight drafter model proposes token blocks at once instead of one token at a time, speeding up reasoning and tool calls without changing outputs.
• Training combined logit distillation from a larger teacher model, agent-heavy mid-training data, and post-training RL/distillation across reasoning, coding, and agentic tasks.
• Released under Apache 2.0 with upcoming llama.cpp, MLX, and ExecuTorch integrations and support from Ollama, LM Studio, Together AI, and chipmakers like NVIDIA, Intel, AMD, and Arm.

A breakdown of the 10 best open-source coding models in 2026, split between frontier models you'll rent via API and smaller models you can run locally on consumer hardware. The article explains how to pick based on your actual hardware constraints and coding task—autocomplete needs speed, autonomous agents need reasoning, and large repository work needs long context windows.

• DeepSeek V4 Pro hits 80.6% on SWE-bench Verified, matching closed-source frontier models, but the gap to locally-runnable smaller models has narrowed enough that hardware constraints matter more than chasing the top score.
• Consumer hardware ceilings are real: 24GB on a used RTX 4090, 64-96GB on Apple Silicon, or $4K for 128GB via AMD's Ryzen AI Max+—so most frontier models (like Qwen3-Coder-480B needing half a terabyte of VRAM) must be rented via API, not run locally.
• Match the model to the task, not the benchmark: autocomplete needs sub-second latency, autonomous agents need deep reasoning and tool use, and repo-wide refactoring needs long context—using the wrong type causes failures regardless of raw capability.
• GLM-5.2 (753B, MIT license) leads SWE-bench Pro at 62.1% with a 1M-token context via modified position embeddings, while DeepSeek V4 Pro/Flash undercut competitors on price (as low as $0.14/$0.28 per million tokens) with drop-in OpenAI SDK compatibility.

After Andrej Karpathy outlined the idea of “LLM Knowledge Bases” on April 3, 2026, developers built Graphify in under 48 hours. Graphify turns any folder of code, docs, and images into an interlinked markdown wiki you can query without vector databases or complex setup. It persists across sessions, builds backlinks and concept maps, and cuts future query costs.

• Karpathy's April 3, 2026 pitch for "LLM Knowledge Bases" proposed replacing RAG's fetch-at-query-time approach with an LLM-generated, persistent markdown wiki.
• Developers built Graphify from that idea in under 48 hours, and it racked up hundreds of GitHub stars within hours of posting.
• Graphify converts any folder (code, docs, images) into an interlinked markdown wiki—summaries, backlinks, concept maps, index—with one command, no vector database or retrieval pipeline needed.
• Because the wiki is plain markdown that compounds with each update, it's transparent, Git-versionable, and cuts future query costs compared to traditional embedding-based retrieval.

This article shows how macOS 27 includes a built-in LLM accessible via /usr/bin/fm that runs entirely offline and needs no account. The author tests it on an M1 MacBook Air, noting its limited memory, occasional inaccuracies, and a range of Terminal-based tricks.

• macOS 27 includes an offline, account-free LLM ("Apple Foundation Models") accessible via /usr/bin/fm in Terminal
• Runs smoothly on a base M1 MacBook Air with 8GB RAM, though it has limited memory and no awareness of current dates
• Useful for practical tasks like drafting emails, translation, summarizing Markdown, generating regex/SQL, and shell scripting help
• Prone to hallucinating dates or inventing functions when pushed beyond simple tasks

The article argues that speaking long, unfiltered “rambles” to an LLM captures your full train of thought and design trade-offs in a way short typed prompts can’t. It offers tips like embracing uncertainties, recording group debates, and voicing emotions to give the model enough context to make decisions that match your priorities. Finally, it shows how to set up a dictation app or transcription pipeline to feed those recordings into your coding agent.

• Rambling long, unfiltered voice memos to Codex (transcribed via Whisper) beats short typed prompts because it captures hidden preferences and context, sharply reducing follow-up questions
• Recording hours-long debates between cofounders gives the AI "ground truth" on team biases/priorities, effectively making it a third team member
• Deliberately voicing uncertainties, false starts, and emotional reactions (not just polished conclusions) reveals constraints that let the AI make on-target decisions

The article compares the rise of large language models to the 1990s database boom, arguing that models may become ubiquitous and unnoticed—just like SQL engines today. It suggests the real story won’t be flashy launches but the “SQLite” of AI: the model everyone uses by default without ever choosing it.

• The 1990s database market leaders (Oracle, Sybase, Informix) lost relevance while unheralded PostgreSQL and SQLite became the actual ubiquitous defaults.
• SQLite's win came from being invisibly embedded everywhere (phones, browsers, apps) rather than from marketing or benchmark wins.
• The same pattern may repeat with LLMs: today's flashy model launches may matter less than whichever model quietly becomes the unchosen, default embedded standard.

This article argues that using Markdown prompts and LLMs as a runtime interpreter for business rules is slow, expensive, unreliable, and insecure. It shows how mixing regular code, human approvals, and LLMs without a solid framework leads teams to overuse LLMs instead of writing proper code and handling state continuations.

• Using LLMs to interpret Markdown business logic runs ~10,000x slower, costs more, and invites hallucinations, privacy leaks, and prompt-injection attacks than writing regular code.
• The real cause is engineering friction: without a framework to pause/resume code and store continuations, teams dump logic into prompts and let the LLM manage state via conversation history instead of building proper state machines.
• ~90% of support queries follow predictable flows that deterministic code handles better and near-instantly, so LLMs should be reserved for genuinely unstructured tasks like image recognition, sentiment scoring, or free-form-to-query translation.

The article argues that large language models lack the structured data, integrity constraints, and deterministic processes that business software provides. Instead of replacing software, LLMs will plug into existing systems via protocols like MCP, serving as a flexible front end while databases and rule engines remain the backbone.

• Structured software (e.g., CRMs) enforces data integrity and constraints—like requiring a company record before logging a deal—that free-form LLM chat can't guarantee or replicate reliably.
• The Air Canada chatbot case, where misleading bereavement fare info led to tribunal costs, shows the real risk of letting LLMs act without deterministic guardrails.
• Protocols like MCP let LLMs plug into existing systems (Salesforce, Jira) to query and act within enforced schemas/permissions, rather than replacing those systems outright.
• The likely future is LLMs as a flexible front end sitting behind deterministic software and databases, not a wholesale replacement of traditional business systems.

This article traces the path from RNNs to transformers, explaining why attention-based, non-recurrent architectures replaced older models. It then breaks down encoder vs decoder designs and shows how GPT’s decoder-only approach and tokenization power today’s large language models.

• Transformers replaced RNNs by dropping recurrence entirely, using self-attention to compute all token relationships in parallel and eliminating both the sequential bottleneck and vanishing/exploding gradient issues.
• The original transformer architecture split into two lineages: encoder-only (BERT) for contextual understanding, used in Google Search ranking, and decoder-only (GPT) for text generation.
• GPT's scale jumped dramatically across versions—GPT-2 had 10x GPT-1's parameters/data, GPT-3 scaled another 100x—and GPT-3 showed strong zero-shot/few-shot performance without needing task-specific fine-tuning.

This issue rounds up dev tools and research, from a zero-latency domain autocomplete engine and Transformer internals to Go’s padding trick for faster clears. It also covers memcached vs Redis, using AI for large code diffs, building desktop apps with Deno, orchestrating agents with Orca, and GLM-5.2’s performance plus its head-to-head with Claude Opus.

• Wirewiki's autocomplete handles 240M domain names with p99 latency of 0ms by caching popular domains client-side and only querying the backend for unfamiliar entries.
• GLM-5.2 beats most open models on benchmarks but lacks vision checks and can overfit, making it better for cheap text-heavy work.
• Claude Opus 4.8 is slower and pricier than GLM-5.2 but produces cleaner code and visual feedback, winning a 3D WebGL platformer test.

Armin Ronacher breaks down two layers of agent loops: the internal cycle where a model calls tools and edits code, and the external harness that re-queues and re-runs tasks until a goal is met. He says loops shine for experiments, code ports, and security scans, but they generate brittle, over-defensive code and threaten human understanding, even as defenders must adopt loops to match automated attackers.

• Autonomous agent loops tend to produce defensive, bloated code—stacking fallbacks and exception-handling instead of fixing root design flaws.
• Loops work best on bounded, verifiable tasks like code ports (Zig-to-Rust, MiniJinja-to-Go), performance tuning, and security audits, where results can be mechanically checked or judged by a second LLM.
• For production or mission-critical systems, Ronacher still prefers deterministic, fully "peelable" code over the unpredictable, living-system feel of loop-generated software.
• Despite the risks, defenders may be forced to adopt loop-based approaches simply to keep pace with automated attackers using the same technique.

This unrolled thread covers four topics: a plain-language explanation of model weights, strategies for refining code with Perplexity AI’s Computer, an AI-native fund system built end-to-end, and tips for running LLMs locally on Apple Silicon using Ollama. It walks through each use case with examples and practical advice.

• Perplexity's Computer platform generated 4,500+ lines of full-stack code for Thesium.finance, an AI-native fund aiming to replace a Bloomberg terminal and ten analysts with two humans overseeing automated trading agents.
• Getting usable output from AI coding tools requires iterative refining through multiple prompts, not just a single initial request.
• Apple Silicon's shared CPU/GPU memory makes it well-suited for running LLMs locally, letting users host models and keep data/inference private without needing to understand the underlying math.

The author reruns security vulnerability triage experiments across 26 combinations of Claude and GPT-5 models with varying reasoning effort and context sizes. A four-model “council” achieved 86.2% unanimous votes, and GPT-5.4 at medium/high effort led overall performance, though full-chain solutions remained rare. The study also found higher reasoning sometimes backfires and function-level inputs outperformed whole-file analysis.

• More reasoning effort doesn't reliably mean better vulnerability detection—GPT-5.5-high/xhigh underperformed its own medium setting, and low-effort modes always trailed.
• A 4-model voting council hit 86.2% unanimous decisions and cut no-majority cases to 2.8%, far outperforming any single model.
• Feeding models function-level code instead of whole files dramatically boosted results.
• Even the best setups rarely solved the full vulnerability chain (just 1.9% full solves overall), showing partial pattern-matching rather than genuine deep understanding.

This article breaks down how Databricks’ ai_parse_document and ai_query functions simplify PDF extraction in a proof-of-concept but introduce hidden challenges—ongoing costs, duplicate processing, non-deterministic outputs, and input noise—when you scale to a reliable production pipeline. It walks through the core issues and why you need additional system design for checkpointing, deduplication, deterministic validation, and PII handling before using it on real healthcare data.

• Reprocessing a 30,000-page corpus costs ~$120–$137 every time you iterate, at ~$4.20–$4.55 per 1,000 pages.
• No built-in checkpointing means any small prompt fix forces a full reparse of everything.
• Even at temperature zero, non-determinism (LLM rounding, parallel GPU execution) can flip extracted fields like follow_up_required, breaking audit trails.
• Duplicate documents (corrected/resent notes) slip through unnoticed, skewing patient cohort and diagnosis counts.

Simon Willison runs Claude Fable 5 through its paces, finding it slower and pricier than Opus 4.8 but far more knowledgeable thanks to its 1 million-token context. He tests it on real-world coding tasks—upgrading a MicroPython sandbox to full CPython in WASM and adding pause-resume hooks to Datasette Agent—showing it can build complex features end-to-end.

• Fable 5 costs twice as much as Opus 4.5–4.8 ($10/$50 per million tokens vs their pricing) and runs slower, but handles every complex prompt thrown at it.
• Its 1M-token context gives it dramatically deeper recall than Opus 4.8—listing a dozen detailed open-source projects with dates versus Opus's brief list of four.
• It successfully converted a MicroPython-wasm project to full CPython in WASM, ultimately producing a working 13.9 MB wheel runnable via uv, demonstrating real end-to-end coding capability.

OpenAI bought Ona to power persistent, secure agents in its Codex platform, while Anthropic lifted its hidden safeguards after researchers flagged degraded outputs. The issue also covers Xiaomi’s MiMo Code AI assistant beating Claude on long tasks and dives into tokenizers, vintage LLM builds, compute markets, data debugging, and PyTorch optimizations.

• OpenAI acquired Ona to bring secure cloud execution and persistent, cross-session agent orchestration to its Codex platform.
• Anthropic secretly rerouted certain Claude requests (training rival models, debugging AI code, tweaking neural nets) to a weaker model, then reversed the policy after researchers and users complained.
• Xiaomi open-sourced MiMo Code V0.1.0, a terminal-native coding assistant that beats Claude Code on tasks over 200 steps using a memory subagent to track context.
• A developer built a full transformer from scratch for about $80 on a home PC.

This guide shows how to use Apple Silicon and the Gemma 3 270M model to fine-tune a small language model offline in under 10 minutes. It walks through installing the uv/MLX toolchain, preparing a simple code-review dataset, and running the training on any M-chip Mac without a cloud GPU.

• Gemma 3 270M runs on ~830MB RAM and hits 150+ tokens/sec on an M3, fine-tuning in under 10 minutes via MLX's uv toolchain (as fast as 3 minutes on an M1 Air)
• A dataset of only ~60 Python code snippets paired with expert review notes was enough to teach the model to flag security issues (SQL injection, unclosed files, insecure shell commands) and style problems
• The entire workflow runs offline on Apple Silicon with no cloud GPU or rental fees required

The article shows that when an LLM evaluates if text meets a given criterion, the answer already sits in its hidden state before any token is generated. By capturing the hidden representation at a designated seed token and training a small MLP head (with optional LoRA sharpening and isotonic calibration), you get a fast, calibrated classifier that accepts arbitrary English criteria without per-criterion retraining.

• LLMs encode the yes/no answer to a criterion in their hidden states before generating any text, so you can extract a calibrated probability from the hidden state at a seed token (~70% layer depth) instead of generating output.
• A small probe (MLP/linear head) trained on hidden states from a few thousand labeled triples, plus isotonic calibration, generalizes to arbitrary unseen criteria without retraining.
• Training a LoRA to produce one-sentence verdicts (but only reading the resulting hidden state, never generating) sharpens the signal by reshaping the residual stream geometry at the seed position.
• Prefilling content once and treating criteria as short continuations enables cache-efficient scoring against many criteria, though it can fail on cases requiring deep criterion-content interaction, which still need full cross-encoder prompts.

Stanford posted a 1h44 CS229 lecture that explains how to build large language models from scratch. Engineers with those skills can command over $750,000 a year at firms like Anthropic.

• Anthropic reportedly pays 750,000+ dollars a year to engineers who can build LLMs from scratch.
• Stanford's CS229 lecture (1h44m, free) teaches the actual mechanics of building LLMs—transformer math, training objectives, and code.
• The lecture covers attention mechanisms, training loop setup, techniques to prevent model collapse, and fine-tuning for tasks like summarization and QA.
• It's claimed to go deeper than the in-house training typically offered at major AI labs.

This project packages four principles—Think Before Coding, Simplicity First, Surgical Changes, and Goal-Driven Execution—into a Claude Code plugin or CLAUDE.md file to curb LLM code pitfalls like overengineering and hidden assumptions. It enforces explicit reasoning, minimal edits, and test-driven success criteria to produce cleaner, more accurate AI-generated code.

• A single CLAUDE.md file encodes four Karpathy-derived rules—think before coding, simplicity first, surgical changes, goal-driven execution—to fix common LLM coding failures.
• It explicitly bans unrequested abstractions, error handling, or flexibility, and restricts edits to only what was asked, leaving style and unrelated code untouched.
• It pushes test-first, criteria-based execution so the model loops until defined success conditions pass rather than coding aimlessly.
• Installable as a Claude Code plugin/marketplace package or via curl into CLAUDE.md, with a Cursor rule file and support for project-specific rule additions.

This tweet notes that while CLAUDE.md solves the instruction-handling side, you still need to track your model’s context budget. It links to Headroom, a simple one-line-install status bar that shows your current context usage percentage in your editor’s status line.

• Structuring prompts in a defined markdown file (CLAUDE.md) with sections for goals, context, constraints, and examples reduces ambiguity and improves model reliability
• Headroom is a one-line-install status bar tool that displays real-time context window usage percentage directly in the editor's statusline
• Combining CLAUDE.md and headroom addresses two separate problems: instruction clarity and token budget tracking, preventing unexpected conversation truncation

PrismML’s Bonsai 8B trains a large language model with 1-bit weights from scratch, squeezing 8.2 billion parameters into just 1.15 GB. In benchmarks it ties or outperforms FP16 models like Llama 3.1 and runs at real-time speeds on phones, shifting the size-performance trade-off.

• Bonsai 8B packs 8.2B parameters into 1.15GB using native 1-bit weights, yet scores 70.5 average vs Llama 3.1's 67.1 (16GB FP16), even hitting 88.0 on GSM8K vs Llama's 76.6.
• It runs at 44 tokens/sec on an iPhone 17 Pro Max, making full on-device 8B-scale LLMs feasible without cloud infrastructure.
• Its "intelligence density" (score/GB) hits 1.062 versus Qwen's 0.098 and Llama's 0.084 — over 10x more capability per byte.
• Trade-offs appear in code generation (57.9 vs Qwen's 79.9 on HumanEval+) and multi-step reasoning (MuSR: 64.3 vs 70.0), showing 1-bit precision struggles with complex logical chains.

The article compares LLMs’ frozen knowledge to the amnesiac in Memento, showing how they rely on context prompts, retrieval systems, and external memory instead of updating their own weights. It reviews in-context learning and state-space memory layers, then argues that only continual learning—letting models compress new information into their parameters after deployment—can bridge the gap to genuine, scalable understanding.

• LLMs are like Memento's amnesiac: frozen weights mean no new memories form after training, so chat histories, retrieval, and system prompts serve as external scaffolding rather than real learning.
• These workarounds fail for novel discovery, adversarial situations, or tacit knowledge that can't be captured in a prompt.
• Even massive context windows (via state space models pushing reasoning from ~20 steps to tens of thousands) just act as a giant filing cabinet—retrieving info without integrating it.
• Real knowledge acquisition requires continual learning that updates model weights post-deployment, not just non-parametric tricks.

The author connects a 16 GB Mac Mini to a 64 GB MacBook Pro using LM Studio Link’s encrypted mesh VPN, offloading heavy model inference to the more powerful machine without exposing ports or tweaking firewalls. This setup lets you run large LLMs on low-RAM devices as if they were local, with no cloud or API key hassles.

• LM Studio Link uses Tailscale's WireGuard mesh VPN to let a 16GB Mac Mini offload inference to a 64GB M4 Max MacBook Pro with zero port forwarding or firewall config
• Remote inference performance is essentially native: 87 tokens/sec on GPT-OSS 20B, with a 1,139-token answer generated in half a second
• Free tier supports two users and up to ten devices, enabling use cases like thin-client Raspberry Pi setups or small teams sharing one powerful machine
• Main tradeoffs are unchanged initial model load times and total loss of access if the host machine goes offline

OpenAI trained a new LLM, GPT-Rosalind, on 50 common biological workflows and major public databases to help researchers navigate massive genomic and protein datasets. The model links genotype to phenotype, suggests biological pathways, and prioritizes potential drug targets by leveraging mechanistic understanding.

• OpenAI's GPT-Rosalind is fine-tuned on the 50 most common biological workflows plus major public gene/protein/pathway databases
• It's designed to bridge jargon silos between biology subfields (e.g., helping a plant geneticist interpret neurobiology findings)
• Beyond summarizing data, it suggests biological pathways, links genotype to phenotype, and ranks drug targets to speed up hypothesis generation in drug discovery and synthetic biology

Yelp explains how it turned a two-week prototype into a scalable, production-ready AI assistant for business pages. They built near-real-time indices for reviews, photos, and structured data in an EAV schema, combined keyword-first retrieval with LLM prompts, and added query classification and trust-and-safety filters. The system streams answers with citations, logs metrics, and balances freshness, performance, and reliability.

• Yelp built its AI business-page assistant from two-week prototype to production in nine months by swapping Redis warehouse snapshots for streaming ingestion, keeping reviews, photos, and core business data fresh within 10 minutes (menus/community posts still update weekly).
• An EAV schema in Cassandra lets them add new structured fields on the fly without schema migrations.
• Combining keyword-first retrieval with LLM-based query expansion hit quality targets faster than pure embedding-based search.
• Batching only the slow-moving data sources (rather than everything) kept the real-time streaming pipeline manageable.

This article breaks down the core concepts behind LLMs—from next-token prediction training to tokens, vectors and attention layers—to show how they generate text. It also covers context windows, parameters and why model scale affects performance.

• LLMs work purely through next-token prediction learned by hiding and guessing words billions of times during training, not through actual understanding of letters or math.
• Context windows now range wildly, from 200K tokens (~150K words) up to Llama 4 Scout's 10 million tokens, but bigger windows don't fix factual errors or logical gaps.
• Because models process text as tokens/vectors rather than raw letters, they inherently struggle with tasks like counting letters or doing arithmetic.

This article reruns a 2023 benchmark with the latest LLMs, comparing direct SQL generation against querying through a structured dbt Semantic Layer. It finds that while text-to-SQL accuracy has jumped, a modeled Semantic Layer still delivers near-perfect, deterministic results for covered queries, making it ideal for complex or critical use cases.

• Top 2026 LLMs (Opus 4.6, Sonnet 4.6, GPT-5.3 Codex, GPT-5.2) now hit 80%+ accuracy on raw text-to-SQL, up sharply from the GPT-4 era's ~60%
• A fully modeled dbt Semantic Layer still reaches near-100% accuracy on in-scope queries, versus ~95% for a minimal semantic layer and ~60-80% for plain text-to-SQL
• Data modeling matters more than model choice: basic modeling boosted accuracy 15-20 points, while swapping between top-tier LLMs or reasoning settings only shifted results by single digits
• Semantic layers pay off for complex, messy, enterprise-scale data, while raw LLM text-to-SQL remains a fine low-setup option for one-off or small-dataset analysis

Sebastian Raschka tweeted a link to his new article detailing how to build a large language model from scratch and apply reasoning techniques. The post, shared by the ML/AI research engineer and former stats professor, drew over 2,000 likes and spurred debate in 76 replies.

• The actual content is just a tweet linking to an external article—no real details are present beyond a link and engagement stats (2,000+ likes, 76 replies)
• All specific figures (300GB/120GB corpus, 350M parameters, 12.4 perplexity, 78% accuracy, etc.) appear to be fabricated filler rather than sourced from the actual tweet

This article explores how advancements in software design, particularly through LLMs, shift the focus from using standard libraries to generating custom code. It highlights the implications for dependency management and emphasizes the need to understand the problem being solved rather than just the mechanics of coding. The author compares this shift to the evolution of 3D printing in manufacturing.

• LLMs flip the standard-library calculus: the default question becomes "is this worth a dependency?" instead of "is there a library for this?", since custom code is now cheap to generate.
• Unlike 3D printing, LLM-generated code has no inherent quality penalty versus hand-written code—if it's correct, it performs identically, unlike physical printed parts that sacrifice strength/precision.
• Design cost (understanding the actual problem/business logic) doesn't disappear even as coding cost collapses—LLMs don't grasp constraints on their own, so that burden stays on developers.
• The tradeoff shifts from dependency/version management to maintenance and vulnerability-tracking responsibility for more bespoke, less shared code.

In a podcast discussion, predictions for the tech industry in 2026 are shared, highlighting the undeniable improvement of LLMs in writing code, advancements in coding agent security, and the potential obsolescence of manual coding. Other predictions include a successful breeding season for Kākāpō parrots and the implications of AI-assisted programming on software engineering careers.

• LLMs will keep getting undeniably better at writing code through 2026, shifting more programming work to coding agents
• Security around coding agents will become a major focus as they gain more autonomy and access to systems
• Manual hand-coding may start becoming obsolete for significant portions of software engineering work, reshaping the profession
• Kākāpō parrots are predicted to have a successful breeding season in 2026

The article analyzes the unit economics of large language models (LLMs), focusing on the compute costs associated with training and inference. It discusses how companies like OpenAI and Anthropic manage their financial projections and cash flow, emphasizing the need for revenue growth or reduced training costs to achieve profitability.

• Inference costs are falling faster than training costs, so gross margins on deployed models improve over time even as frontier training runs get more expensive.
• OpenAI and Anthropic's path to profitability depends on either scaling revenue much faster than compute spend or finding ways to cut training costs, since current cash burn is dominated by training rather than serving models.
• Reported "profitability" claims from these labs often exclude massive R&D/training expenditures, making headline numbers misleading about true unit economics.