Mayank Bohra

How many books did you read last year? Now how many ideas from those books can you recall right now? Most highlights die inside PDFs. This is trying to fix that. 🧵

@solopribuilds haha nah, my agent's got this 😎 I trust my prompts and the context engineering wrapped around it. it does the work and i scroll 😉.

@MayankBohra06 Ah.. you need some help

I'm curious while AI is writing your code, what are you doing?

@FarzaTV The screen-as-context part is the actual unlock here. Fast STT is table stakes, but dictation that knows what app I'm in? That's the thing I didn't know I wanted. How does it handle multiple windows open at once?

Today we're shipping screen-aware dictation. First, we built a speedy speech-to-text (very fast, ~450ms). But, many products do this! So we went further. Now dictate using your screen as context. In Claude Code, it writes the prompt. In G-Mail, it replies in your voice. Demo:

@MarlinProtocol I made the same API choice in a Python webhook verifier. After the signature check, it returns the parsed event. Before that, callers verified one payload and then had to parse it again themselves.

Builders declare their expectations, from PCRs and image id to a timestamp and user data, and the SDK enforces only what they set. A passing check returns the decoded attestation, ready to act on.

The Marlin Oyster SDK now ships the verification side of EC2 instance attestation. Users of the SDK can check a workload runs the expected code in a locked down environment before handing it anything private, with the checking logic maintained upstream.

@18_priyansh I hit this exact edge while adding idempotency to single and batch email tools. The key had to live in the MCP schema and pass through the SDK request options. Otherwise the agent can retry, but the provider never sees the dedupe signal.

Agents with real inboxes are on the Vercel Marketplace. vc i agentmail, thread memory, structured extraction. Email is the one tool surface with no undo. Retry loops without idempotency keys double-send. Trust bug, not a latency bug. x.com/vercel_dev/sta…

@Randhir_Jassal I keep coming back to this while building MCP tools. A successful tool call doesn't make the result trustworthy. I still validate its shape, limit what the agent can do next, and never let returned text quietly become instructions.

You can't make a model immune to being tricked. So the game is making a TRICKED agent harmless. Part 8 of my MCP deep dive: securing MCP against prompt injection & tool abuse. The twist -- in an agent, the tool RESULT is untrusted input. prepstack.co.in/blog/mcp-deep-…

@simonw @jodiecongirl This matches my best Codex sessions. Most of the work happens before the prompt: deciding what's in scope, what must stay true, how failure should behave, and what would actually prove the task is done. Once I can state that clearly, the prompt is usually easy.

@jodiecongirl I agree with that - the skill isn't so much prompting, it's thinking through problems and then structuring them in a way that can be solved by the coding agents

I still sometimes see people saying "if you know how to write the code, it's faster to write it yourself" I'd argue the exact opposite: if you know how to write it, you gain nothing from doing the typing yourself - outsource that to a coding agent!

@gokulr I've found the same split useful: keep product intent canonical, then generate a tighter contract for the agent. Scope, checks, and evidence to return matter more than a longer prompt. Otherwise the code can pass while the product intent still gets lost.

PRODUCTSPEC: AGENT HANDOFFS We just pushed a meaningful update to the open source ProductSpec repo. ProductSpec now generates Agent Handoffs. That may sound small but I think it is one of the most important pieces of the system. The core idea behind ProductSpec is simple: product intent should be readable by humans and executable by AI agents. A Product Spec captures: • Problem • Hypothesis • Product Summary • Scope • Acceptance Criteria • AI Evals • Success Metrics • Related Evidence But when you hand work to Claude, Codex, Cursor, or another coding agent, the agent often needs a tighter build contract. So we added: productspec handoff specs/example.product-spec.md This generates an Agent Handoff from the Product Spec. The handoff includes: • Build Contract • Product Summary • Scope Guardrails • Must Satisfy • Suggested Verification • AI Evals • Existing Evidence And Links • Evidence To Return The important design choice: Agent Handoff is generated. It is not a new canonical section inside the Product Spec. The Product Spec remains the source of truth. The handoff is the execution view. We also added the same capability to the MCP server: get_agent_handoff So an MCP-aware coding agent can ask ProductSpec for the build contract directly. This is where the Product Harness framing starts to become real. Coding agents are getting better at the inner loop: write code, run tests, fix errors, repeat. But the outer loop matters just as much, if not more: • What should be built? • What is explicitly out of scope? • What proves the work is done? • What evidence should come back? • When should the agent stop because intent changed? ProductSpec is the Product Harness for that outer loop. This release also adds a complete example folder in examples/product-harness/ It shows the full loop: product intent, generated handoff, agent execution receipt, and decision trace. If you are building with AI agents, try this flow: 1, Write a Product Spec. 2. Generate an Agent Handoff. 3. Give it to your coding agent. 4. Make the agent prove every acceptance criterion. 5. Record drift with a Decision Trace when intent changes. The future of product development is not just faster code. It is clearer intent, executable constraints, and better evidence after the work ships.

@Priyanshh91 codex

I have 100$ right now Which one should I buy? Claude code or codex?

@Priyanshh91 🥶

Wish me luck :D

@Fasthecr3ator Exactly 😅 Everything looked healthy at the network layer, which made it even more confusing. The actual issue was in the decoding path. Hope this saves you a few hours if you ever run into it.

@MayankBohra06 Issues like this are such a pain to debug. Gonna bookmark this for later

Spent part of today debugging a blank image preview in tryrehearsal.ai. The upload worked. The endpoint returned 200. The JPEG was only 7 MB. Android still showed an empty box. I kept circling the signed URL because that seemed like the obvious failure. Nope. The photo was 8160×6120, almost 50 megapixels. React Native was trying to unpack roughly 200 MB into memory and quietly giving up. I changed the backend to send a 1200px preview while keeping the original for when someone opens it. The preview went from 7 MB to 732 KB. The image finally showed up. Mostly relief, plus some annoyance that I'd spent so long debugging a perfectly healthy 200 response. Next time an image vanishes on mobile, I'm checking the pixels before I touch the URL code.

I bet highlyt.app whole moat on a human-in-the-loop step. Then I watched almost nobody use it. The design felt principled. You highlight something, the AI suggests how it connects to the rest of your reading, and you confirm it. AI proposes, human approves. The graph grows one approved link at a time. In production that confirm step barely got touched. People highlighted fine. The suggestions showed up. The approve button just sat there. The lesson I should've known: every time you put a human in the loop, you're taxing the user. A click, a decision, a "do I agree." One tax is fine. Charge it on every suggestion and they quietly stop. The reframe that helped me: give the AI a job title. Worker does the task, you ship it. Orchestrator runs the steps, checks in at the big calls. Critic never acts alone, only suggests. I'd made mine a strict critic everywhere, even where a wrong guess costs nothing. The skill isn't "keep the human in control." It's putting the human in the loop only where being wrong is expensive, and getting out of the way everywhere else. Still figuring out where that line sits. But I'm done pretending human-in-the-loop is free. If you've shipped an AI feature with an approve step, what was your real drop-off on it?

Reading about what makes AI startups survive past the demo, and one line reframed it for me: "If you can't define the AI's job clearly enough for an engineer to build an eval suite around it, you don't have a product. You have a demo." In 2026 everyone has the same models. The model is not the moat. The moat is the boring layer: → a clearly defined job the AI is hired to do → an accuracy floor (the point below which it harms the user, not helps) → a deterministic fallback for low-confidence answers → unit economics that survive real token usage A demo works on the inputs you picked. A product works on the input a stranger throws at it. Most "AI startups" never cross that gap. They polish the demo and call it traction. The unsexy truth: the eval suite IS the product. The model is just a dependency. Build the thing that stays reliable when reality shows up. Buy the rest. What broke your AI feature in prod that the demo never revealed? #AIEngineering

Researching a feature for highlyt.app recently, I hit a question that stopped me cold: how wrong can an AI feature be before it becomes a liability? Turns out that question has a number behind it. The accuracy floor. Traditional software is deterministic. You aim for 100% because the logic is either right or it isn't. AI is different. It's probabilistic. It lives in the world of "maybe." So before you build, you define the floor: the minimum performance where the tool is still a net positive for the user. Above it, the feature helps. Below it, you're shipping a risk with a nice UI. The hard part isn't the model. It's being honest about that number before you write a line of code. If you can't name the accuracy floor for your feature, you haven't defined the job yet. What's the floor for the AI feature you're building right now? #AI #BuildInPublic

@ArtificialAnlys Claude Code feels better when I’m iterating inside an existing codebase. Codex feels more interesting when the task can be boxed cleanly. The winner is usually not “which model is smarter”. It’s which one loses less context while editing.

We've updated the Artificial Analysis Coding Agent Index, replacing SWE-Bench Pro with Datacurve's DeepSWE benchmark - the swap lifts Codex with GPT-5.5 (xhigh) above Claude Code with Opus 4.8 (max), while the newly released Claude Fable 5 (max) in Claude Code debuts at the top DeepSWE, built by @datacurve, writes its tasks from scratch rather than adapting them from public GitHub issues or pull requests, so no model has seen the solutions during training. That matters because SWE-Bench Pro, the benchmark it replaces in our Coding Agent Index, had grown gameable, with some models recovering the fix from the repository's commit history instead of solving the task. The swap reorders the index: Codex with GPT-5.5 (xhigh) rises from 65 to 76, overtaking Claude Code with Opus 4.8 (max) at 73. Claude Code with Fable 5 (max), which enters directly on the refreshed index, leads at 77. SWE-Bench Pro had been flattering some combinations and penalizing others. More below.

@ShinkaIoT “better prompts” stop working once the agent has more than 3 real responsibilities. after that, you need structure: files, roles, checks, fallback paths, and context boundaries. prompting becomes system design very quickly.

GPT-5.6 is coming and a price war just started! Most people think "Prompt Engineering" is about writing better instructions. The top 1% know it’s actually an Infrastructure problem. 🧠⛓️ If you are trying to make an AI model perform complex, production-grade tasks using a single, massive system prompt, you are hitting a wall. The model forgets constraints, hallucinates edge cases, and burns through tokens. The secret to reliable AI agents isn't "better words"—it is **Meta-Prompting**. Meta-prompting is the practice of building a specialized structural framework where the model acts as its own compiler, architect, and critic before a single line of final output is written. Here is the exact architectural blueprint to shift your prompt engineering from "vibes" to deterministic systems: 🏗️ 1. The Multi-File System Architecture Stop cramming your context into one prompt box. Look at how advanced frameworks handle agent behavior. They break the model's instructions into modular, system-level files: • `system_prompt.md`: Defines the absolute core identity, safety constraints, and global rules. • `tools.md`: Declares the exact API schemas, parameter types, and execution bounds. • `context_rules.md`: Dictates how memory is loaded, cached, and recalled. By dividing the cognitive load, you maximize token-caching efficiency and keep the model tightly anchored to its boundaries. 🔄 2. The Task-Generation Compiler Instead of manually guessing how to prompt a model for a specific task, you use a Meta-Prompting Loop. You feed a macro-goal into a specialized "Compiler" prompt. The compiler's sole job is to analyze your goal, identify potential logical contradictions, and output a highly optimized, strictly formatted system markdown file tailored for a separate worker model. The AI designs the machine that governs the AI. 👁️ 3. Explicit Chain of Thought (CoT) Hidden Layers Never let a model jump straight to an answer. Force it to allocate compute to planning. By enforcing a strict `` or `` tag at the very beginning of the prompt architecture, you compel the model to map out its execution path, evaluate its own logic, and catch errors *before* it outputs the text or runs a local tool call. 🛠️ 4. The Critic-Worker Pipeline The ultimate step in meta-prompting is decoupling generation from evaluation. You run a two-agent loop: 1️⃣ The Worker: Receives the meta-compiled prompt and generates the asset (code, copy, strategy). 2️⃣ The Critic: An completely isolated model instance with a hyper-strict rubric. Its only job is to aggressively red-team the Worker’s output against the original spec. If it flags a violation, it automatically passes a structured error log back to the worker to initiate a self-correction loop. The Takeaway: The era of guessing which adjectives make an LLM work better is officially over. Elite AI engineering treats models like raw compute engines. By building modular prompt architectures, automated prompt compilers, and strict evaluation loops, you transform an unpredictable chatbot into an industrial-strength autonomous worker. 🖥️🛡️

@btwiambot True. AI engineering is mostly boring backend work with a model sitting somewhere in the middle. queues, retries, evals, logs, rate limits, bad inputs. that’s where the product either works or dies.

AI Engineers today are spending 80% of their time doing Software Engineering and only 20% doing AI Engineering. Building models is often the easy part. The hard part is: • Data pipelines • Distributed systems • APIs & services • Caching • Monitoring • Infrastructure • Reliability • Scaling AI products succeed because of strong software engineering, not just better models.

@dr_cintas the impressive part isn’t “AI made a game”. it’s that story, visuals, and interaction are starting to collapse into one build loop. still messy, but this is exactly where creative tooling gets weird fast.

Claude Fable 5 + Higgsfield MCP is insane. You can now build a playable game with a full story and crazy visuals 🤯

@Dipanshu_AI best Claude resources are the ones that show failure cases, not just clean demos. prompting only clicks when you see where the model goes off-track, then how small instruction changes fix it.