My actual digest.

The new "thinking with visual primitives" technique improves multimodal LLM performance by enabling explicit spatial pointing—using bounding boxes—rather than relying on ambiguous text descriptions. This method is both faster and cheaper, requiring 90% fewer visual tokens than top-tier frontier models. By training student models to learn this visual reasoning from specialized "teacher" models, the approach effectively distills complex spatial navigation skills into lighter, more efficient architectures. While the method still relies on explicit trigger words and may struggle with very high-resolution, complex patterns (like individual strands of hair), it represents a significant breakthrough for AI efficiency and reasoning.

Google is shifting from indexing the world’s information to becoming an interface for reality through AI agents. The keynote showcased how models like Gemini Omni are moving beyond mere text generation to synthesize real-time, interactive UI components on demand—effectively turning search into a dynamic, agentic experience.

While Google’s massive token processing scale (3.2 quadrillion/month) and new TPU architecture for training and inference are impressive, the developer takeaway is the new HTML-in-Canvas API. It bridges the gap between low-level WebGL graphics and accessible HTML, enabling a new generation of interactive, pixel-perfect UIs that are as performant as they are functional.

The goal of business is not to "capture" value through short-term profit maximization, but to create value that people want. Today’s business culture—characterized by short-term shareholder primacy—is inherently corrosive and leads to "temporary" organizations led by temporary managers, damaging trust and longevity.

To build an "incorruptible" company meant to last for 100 years, founders must avoid the trap of "best practices" that prioritize investor returns over mission. Key strategies include:

• Mission-Controlled Governance: Instead of focusing solely on shareholder-controlled or founder-controlled structures, companies should be mission-controlled, ensuring the company’s purpose holds sovereignty.
• Structural Integrity: Techniques like two-branch government structures (with trustees protecting the mission) and incorporating as a Public Benefit Corporation (PBC) from day one are crucial. These structures insulate the company from short-term financial pressure.
• Fiduciary Duty: Founders must recognize the "fiduciary hierarchy" that puts customers first, employees second, and shareholders third—a departure from the conventional wisdom of shareholder primacy.

These structures are not just ideal; they are proven. Companies that align their governance with their mission, like those utilizing "Perpetual Purpose Trusts," are statistically more stable and better equipped for long-term survival. The prevailing "best practice" of prioritizing share price is often just a path to value destruction. Founders should prioritize building a company their grandchildren won’t be embarrassed by, rather than one designed solely for the next quarter's exit.

The core goal is to build a private, self-hosted search engine for life. By leveraging AI to process a personal library of video diaries, users can move beyond simple keyword searches to semantic, meaning-based queries.

The technical architecture rests on embeddings: converting language (in this case, transcripts) into high-dimensional vectors. Similar meanings are mathematically closer in vector space, allowing a computer to search by "vibes" rather than exact words. This system utilizes:

• PCA projection to map these high-dimensional vectors into 2D, creating a visual, clustered representation of memories.
• Timestamped transcript chunking (splitting content into 60-second segments) to move from video-level search to specific, retrievable moments.
• Retrieval-Augmented Generation (RAG) to ground the AI in actual video transcripts, minimizing hallucinations and ensuring citations.

The approach relies on a local LLM—in this case, Ollama—to interpret these chunks and synthesize responses. While the project is a functional, powerful starting point, the current search is limited by text-only transcription. Future iterations could add multimodal embeddings, incorporating image and video data for a more comprehensive, and potentially more accurate, search experience.

Two systems might yield the same result, but the mechanism—the how—is critical for establishing trust. When dealing with complex AI agentic workflows, the process matters as much as the output.

Elicit addresses this by building a custom domain-specific language (DSL) called ÆPL. Its key design choices are:

• Turing-incomplete: Simple, predictable, and loop-free.
• Purely functional: No side effects, ensuring reproducibility.
• Reactive: Built to handle streaming data updates.
• Opinionated subset of Python: Familiar syntax with unnecessary features stripped out to focus on research and decision-making primitives.

This DSL allows Elicit to provide legible, verifiable, and consistent results. By treating the code as an artifact that can be inspected, re-interpreted, and debugged, the system maintains high fidelity even through complex, multi-step iterations. While building a DSL isn't necessary for every project, it is a powerful approach when high-stakes decision-making demands transparency and reliability.

GenSpark, an all-in-one workspace for white-collar work, leverages AI to streamline productivity. For founder Kay Zhu, the company’s success isn't about traditional “moats,” but rather a culture of relentless innovation and deep, mutual trust with partners like Anthropic.

The core philosophy? Don't force paths—follow your heart. In a fast-moving AI landscape, stay curious and embrace the rapid, magical possibilities of tomorrow over rigid long-term planning.

Fighting financial crime is an uphill battle of manual, disjointed data collection—analysts often juggle dozens of browser tabs to build a case. To address this, Qonto built a unified system using Claude Cowork and the Model Context Protocol (MCP) to prioritize security and compliance.

The architecture relies on five core constraints to ensure safe, audited data access:

• OAuth 2.1 + SSO: Propagates verified user identity across all requests.
• Short-lived PASETO tokens: Cryptographically secure tokens for downstream MCP calls.
• RBAC: Centralized, versioned control defining which teams can access specific data.
• Auditing: An append-only log capturing every action taken.
• Human-in-the-loop (HITL): Keeping final decision-making with the human, while AI handles the enrichment and reasoning.

This system uses Claude 3.5 Opus for complex reasoning across million-token context windows, allowing analysts to query disparate data sources—from internal databases to open-source intelligence—in a single, unified interface.

Key takeaway: Treat evaluations (evals) like unit tests for your AI. By defining "what good looks like" upfront, engineering teams can catch regressions before deployment, provide auditors with quantitative proof of system integrity, and build the trust required for analysts to adopt these tools effectively.

The most fruitful domains for AI are high-value fields that rely on either deep technical reasoning (like software) or the ability to identify a few critical data points among millions (like legal work). Patent law exists at the intersection of both: it is a complex, high-stakes domain where AI-driven efficiency provides a clear signal for consequential decision-making.

A patent is a social contract: the state grants an inventor a 20-year monopoly in exchange for a public disclosure of how their invention works. For a patent to be granted, an invention must be:

• Novel: Previously unknown to the public.
• Non-obvious: Not obvious to a hypothetical "person having ordinary skill in the art."
• Useful: Capable of providing a tangible benefit.
• Sufficiently disclosed: Detailed enough for a skilled person to reproduce it.

Patent drafting and prosecution are not purely mechanical tasks. They are adversarial processes where small, deliberate choices in terminology and scope can have massive consequences years later. Consequently, the standard AI "delegation model"—where a user defines a goal and delegates the implementation to an AI—is often insufficient. Unlike software, which can be validated via tests or quality assurance, the "correctness" of a patent claim can only be judged over time, through the lens of future examiner objections, competitor workarounds, and litigation. Therefore, developers should prioritize a collaboration model, centering on three principles:

• Citations as a first-class citizen: AI must provide an auditable trail of sources for every claim, allowing humans to verify accuracy.
• Specific capabilities via a general agent: While a general-purpose AI can handle broad tasks, it must be augmented with specific, specialized tools to handle complex or repetitive workflows.
• Parallelize alignment and sequence execution: Complex legal work cannot be treated as a single "run." Instead, identify critical points for human input (alignment) to steer an autonomous agent toward high-quality results.

AirOps bridges the gap between complex AI agent workflows and non-technical content marketers by focusing on harness engineering—the infrastructure that makes agents usable, reliable, and accountable.

Key strategies for successful AI product deployment include:

• Document-Based IDE: Replacing complex, "brittle" node-based workflows with a document-centric interface. This provides users with familiarity, transparency into tool usage, and granular control to override steps.
• Mandatory Human Review: Embedding "gatekeeper" roles within workflows to ensure brand alignment and governance, preventing "AI slop" from being published.
• Specialized Subagents: Decomposing tasks into focused sub-processes (compliance, writing, brand-kit, etc.) to optimize token usage and prevent context window overload.

This approach moves agents beyond "toys" into production tools. Case studies show this architecture yields a 130% increase in citation rates and cuts production time from months to weeks.

Large Language Models have triggered an explosion in job applications, making it impossible for recruiters to review them manually. Metaview addresses this with an AI-native recruiting system that treats Large Language Models as an apprentice, not an automated decision-maker. The Core Technique:

• Human-Centric Design: The system keeps humans in the center of the loop. Recruiters make final decisions on candidates, and the AI agent observes those decisions to identify patterns.
• Self-Improving Prompts: The system maintains an "Ideal Candidate Profile" (ICP) in natural language. As the agent observes recruiting decisions, it continuously updates this profile, ensuring the AI's criteria evolve alongside shifting hiring priorities.
• Guardrails via Architecture: Rather than layering complex logic on top of the model, the system builds guardrails directly into the workflow, ensuring the model remains efficient and aligned with the recruiter's evolving intent.

Key Takeaways:

• Preferences Evolve: Because user judgment is at the core, systems must be built to adapt. Avoid rigid, hard-coded rules.
• Prose, Not Rules: Lean into the strengths of LLMs. Let them reason in natural language rather than forcing them into deterministic filters or complex flowcharts.
• Keep the System an Apprentice: AI is an aid, not the master. Structure your architecture to support human expertise by automating the "grunt work" while deferring high-stakes judgment to the human.

Building functional, autonomous agents requires moving beyond rigid, rule-based prompts. Instead, focus on designing iterative feedback loops that allow agents to evolve.

• Embrace Principles Over Rules: Rules are brittle and easily broken by edge cases. Replace them with core principles that provide a framework for judgement, such as "don't get defensive" or "sound like a product builder." Principles are flexible and translate better to new, unseen situations.
• Teach the Agent to Learn: Create an "agent-as-a-teammate" dynamic. Rather than just correcting output, provide feedback that explains why an action was good or bad. This allows the agent to update its own instructions and improve over time.
• Design Low-Friction Feedback Loops: Feedback should be as close to zero-effort as possible for your team. Integrate interaction into existing workflows—like adding a simple emoji reaction in Slack—to signal to the agent which automated actions were helpful and which should be skipped.

This approach shifts the burden from constant manual prompting to the continuous improvement of the agent's internal instruction set. The result is a system that grows more capable, context-aware, and effective without requiring an army of human overseers.

Agentic software engineering requires moving beyond simple prompting to creating custom agent environments. The core thesis is that if Claude cannot perform tasks you can do, it cannot be a effective collaborator; your job is to create "little clones" of yourself to scale work across multiple agents. Success requires optimizing three pillars of agent customization:

• Access: Claude must be able to "see" where your work happens. If you find yourself alt-tabbing to copy-paste between tools like Slack, Email, CI/CD, or internal documentation and your terminal, you are losing valuable context. Connect these tools to the agent to streamline workflows.
• Knowledge: You cannot "train" a model on your specific internal conventions, APIs, or institutional memory. Instead, use "in-context learning"—injecting relevant, up-to-date information directly into the agent's context window.
• Tooling: Build an "IDE for Claude" using agents that provide immediate feedback (the equivalent of red squiggly lines for code). This shortens the feedback loop, allowing agents to correct their course instantly rather than waiting for human code review.

Context Window Management is the ultimate constraint. Think of it as a limited resource, like trying to run npm on an Arduino.

• Packaging Strategy: Be intentional about what goes into the context. Include stable, shared information at the beginning, and keep volatile, per-task data at the end to minimize re-computation costs.
• Plugins and Abstractions: Use primitives like MCP, skills, and hooks to keep agents lightweight.
• Worktrees: Utilize Git worktrees to allow multiple Claude instances to operate on different branches simultaneously without context-switching conflicts.
• Agent Teams: Enable agents to communicate with each other via tools like sendMessage. This allows for specialized sub-agents that can offload work from the main loop, keeping the primary context window lean and focused.

The most effective agents are not necessarily those powered by the largest, most "intelligent" models, but those equipped with the tightest, most efficient feedback loops and the cleanest access to necessary data.

The bottleneck in software engineering has shifted. For years, the constraint was engineering bandwidth—leading to slow, heavy processes like exhaustive planning and manual reviews to "protect" that expensive resource. With modern AI, coding is rarely the bottleneck anymore.

To evolve, teams must rewrite their core norms:

• Code, don't document: Swap "design docs before code" for "prototype first." If a design doc is needed, it follows the implementation.
• Trust, but verify: As throughput increases, verification becomes the new bottleneck. "Shift left" by automating tests, linting, and bug triage to catch issues at the source.
• Manager as IC: Every manager should remain an individual contributor. You cannot effectively coach, mentor, or iterate if you aren't in the code.
• Embrace "Dogfooding": Actively use your own product. It’s the only way to build authentic product sense and identify genuine user needs.
• Automate, then humanize: Use AI for boilerplate and standard patterns, but keep human experts in the loop for risk-sensitive work, legal reviews, and strategic product decisions.

The takeaway: Pick your noisiest, most time-consuming workflow and ask if it still earns its place. If it only exists because engineering was once expensive, kill it. Modernize one workflow at a time.

Maximize your LLM investment with these three pillars of context window engineering:

• Prompt Caching: This is non-negotiable. Aim for at least an 80% cache hit rate to slash costs by 90%, bypass rate limits, and drastically reduce latency. Audit your cache hit rate in the Claude console to identify and fix breaking changes in your prompt structure.
• Tool Search: Define your tools upfront, but avoid dumping all schemas into the context window. Use a search-based approach to inject only relevant definitions on demand. This saves tokens and can actually improve model performance by eliminating irrelevant data.
• Programmatic Tool Calling: Don't feed raw, bloated tool outputs to the model. Write simple Python scripts to parse, filter, and cross-reference results, ensuring only the essential, actionable information reaches your agent.

A word of caution: The "Advisor Strategy"—using a smaller, cheaper model like Sonnet for execution and a smarter model like Opus for intermittent oversight—is effective, but monitor your agent's transcript. Trust your inspection of the logs over any single dashboard metric.

Prompting is a fundamental engineering skill, best treated as a continuous, iterative process of debugging rather than a one-time writing task. Effective AI development relies on three core practices: evaluation, structure, and decomposition. 1. Prioritize Evaluation: You cannot improve what you don't measure. Establish a representative eval suite early—including control cases, known edge cases, and "refusal" cases—to distinguish between model capability shifts and your own prompt changes. Evaluations provide the necessary data to determine if a fix actually works or if it introduces new regressions. 2. Structure and Hygiene: Don't let prompts become "large and disorganized." Use XML tags to logically separate system instructions, data, and policy. If you can’t easily distinguish these sections when reading your own prompt, the model likely can't either. As prompts evolve, keep them clean by removing obsolete patches. 3. Decomposition and Tools: Instructions don't grant new capabilities. Avoid asking the model to perform complex mental math or handle nuanced logic in a single pass; it will hallucinate or over-fit. Instead, provide external tools for calculations and lookups. When tasks grow complex, transition from a monolithic prompt to a structured "chain-of-thought" or multi-agent architecture (e.g., generate, evaluate, and repair) to isolate and systematically fix failures.

The capability curve describes the rapid increase in AI-driven software development over the last 12 months. Where models previously struggled with simple coding tasks, frontier models like Opus 4.7 now achieve 87.6% on SWE-bench Verified—a benchmark once saturated by less capable versions. Key advancements in model intelligence are driving this shift:

• Planning before acting: Models now proactively read, plan, and self-correct during execution rather than acting blindly. Developers should select high-reasoning settings and allow models time to develop these strategies autonomously.
• Improved error recovery: Models no longer fall into "doom loops." They effectively process feedback from the environment to adjust their approach mid-task, increasing success rates while reducing token consumption.
• Sustained attention: With coherence now spanning millions of tokens, developers no longer need to break tasks into tiny, manual chunks. You can provide a full codebase and let the model handle the complexity.

How to adapt your workflow:

• Refresh your evals: Move away from static academic benchmarks. Build evaluations based on real-world production traffic and failure modes specific to your application. If a model aces your current test, it’s time to raise the bar.
• Shrink your scaffolding: Avoid "Frankenstein prompts" designed to patch old model weaknesses. As models improve, pare down instructions and focus on intent rather than specific, outdated workarounds.
• Give the model room to work: Use "auto mode" to allow models to perform tool calls autonomously, only looping in humans when necessary. Close the agent loop by allowing the model to inspect its own outputs and iterate on them, turning the system into a self-improving engine.

To move fast, drop the legacy of heavy planning. Forget Product Requirement Documents (PRDs), vision decks, and OKR meetings. Instead, prioritize rapid prototyping and user feedback. The secret is to make your iteration loop as tight as possible.

• Design by talking: Record meetings with users, transcribe them, and ask the AI to suggest features. Prototype immediately, share it, and iterate.
• Build on the edge: Don't try to build the perfect product; prototype what almost works on today's model. As model capabilities increase, your "almost" features will naturally click into place.
• Keep teams small: Limit teams to 3-5 people. When everyone is responsible for talking to users, designing features, and shipping code, you eliminate the friction of coordination.
• React, don't document: Use transcripts as your roadmap. When a user reports a bug, set a 24-hour fix target. This forces you to identify and remove bottlenecks in your development process.

A final caveat: Don't fear the occasional failure. You will build the wrong thing. What separates successful, fast-moving teams is how quickly they notice a mistake and course-correct.

Taking Retro Rewind for a test drive, this showcase highlights the mod’s ability to enable custom character models in online play. Moving away from the typical “meta” characters like Funky Kong, the session cycles through a diverse roster—from a golden Mii to King K. Rool and even a literal snowman. While the aesthetic variety adds a fresh, chaotic flair, the performance remains largely consistent with standard Mario Kart Wii gameplay, proving that the mod’s true appeal lies in personal expression rather than shifting the competitive balance.

If you're ever on the dance floor and suddenly hit with a fast beat you don't know how to handle, rely on this simple step-by-step foundation: soften your knees and start alternating your weight from leg to leg.

Build on this basic movement with these techniques:

• Add hip isolations: Introduce a side-to-side sway, ensuring your hip reaches toward your leg on every count.
• Incorporate rotation: Keep your weight balanced between your legs to allow your torso to move independently, like a bottle cap spinning on a bottle.
• Add vertical accents: Shift your weight onto one leg and isolate your hip movement with a sharp up-and-down motion.

These elements create a polished, professional look. Practice these in isolation, then layer them together, keeping your rhythm consistent regardless of the tempo.

André Rieu's Maastricht concerts are a masterclass in turning a classical performance into a jubilant, communal experience.

• Orchestral engagement: Instead of a stiff, formal atmosphere, the performance is marked by joy—dancers in sweeping gowns mingle with the audience, and the conductor actively dances and jokes with the crowd.
• Communal spirit: The footage captures a sea of thousands united in song, laughter, and spontaneous dancing, blurring the lines between performer and spectator.
• Atmospheric production: A sophisticated mix of nighttime pyrotechnics, confetti cannons, and soaring classical arrangements creates a festive, open-air gala that feels both grand and incredibly intimate.