Speaking into the mic: Building for two audiences.

Hey everyone, it’s been a while :) But as always, I promise to only write when I feel I’ve stumbled into something genuinely interesting.

I’ve been running Ritua as CEO and Product Manager for a little over 2 years now, and I’ve picked up some insights along the way. The biggest one is subtle, but I think it’s going to define the next decade of tech:

We’re slowly no longer speaking to/or building for humans. We’re speaking into the mic.

As you read through this post, I’d love to hear your thoughts. Disagreements, hot takes... All welcome on Twitter/LinkedIn/Substack

Over the past year, tech headlines have been dominated by new AI tools that speed up productivity (”Cursor for X” is a common format), improve customer understanding and even transcribe your Zoom calls. Yet no one in Product has talked about the elephant in the room:

A significant and increasing share of our daily interactions are being consumed by AI first, humans second.

Look around:

• Our meetings are riddled with bots, and we know it. I’ve noticed that people (myself included) have started asking more direct, explicit questions in meetings. Not because the person across the table needs the clarity, but because we want the AI note-taker to capture the right context. We’re performing for Granola, Otter, Fireflies. Not for each other.

• Our PRDs aren’t written for human consensus anymore. They’re written so they can be copy-pasted into Claude Code, Cursor or Copilot for prototyping. The structure, the specificity, the level of detail... it’s optimized for the machine that will build it, not the human who will approve it.

• Our Jira and Linear tickets are written for AI context. We’re careful about wording, explicit about acceptance criteria, not because a teammate needs hand-holding, but because the AI coding agent needs as much context as possible to do a good job. (Sometimes opened, written, executed and closed entirely by AI)

• Our resumes are written with AI…to be scanned and parsed by ATS AIs. Human eyes might never see them.

This is what I mean by “speaking into the mic.” Imagine two people having a conversation, but there’s a third element in the room. Visually invisible, yet arguably the most important participant. It’s the recording device that will relay, parse, and repackage your words long before they reach another human.

Whether we like it or not, the first reader of most of our work is no longer a person. The chain increasingly looks like human → machine → machine → human, with more “machine” in the middle every month.

If we zoom out, this behavioral shift is just the beginning. The real transformation is structural, and it’s been building for decades.

Phase 1: Human discovers, human consumes (90s). Products were 100% human-to-human. Web portals, chat rooms, early e-commerce... everything was designed for a person to discover, read and click. The internet still hadn’t figured out how to format text for different screen sizes (Dreamweaver websites built with <table> tags were very much a thing), but one thing was clear: everything had been written by a human, for a human.

Phase 2: Machine discovers, human consumes (2000s–2010s). Products were still consumed by humans, but increasingly discovered by machines. To be seen you had to seduce the algorithm. Clickbait headlines, keyword stuffing, viral loops and echo chambers became the cost of doing business. The human was still the end user, but the algorithm became the gatekeeper.

Phase 3: Machine discovers, machine consumes (now). The machine doesn’t just read and rank anymore. It parses, summarizes and acts long before a human enters the loop. Your content gets digested by an AI before anyone reads it. Your product gets evaluated by an agent before anyone tries it. The gatekeeper became the audience.

This brings us to something I think will define the next era of tech.

We went from B2C (building for people), to B2B (building for companies), and now we’re entering B2A: building for agents.

YCombinator recently put out a piece playfully shifting their legendary motto from “make something people want” to “make something agents want.” I somewhat agree, but I think the nuance is important:

Right now, we’re building software for people, but our interactions are already for the AI. Soon, we’ll be building for AI, with interactions designed for both humans and agents.

You can already see this happening. Supabase is exploding. Resend is exploding. Not necessarily because a human PM sat down and compared every option, but because when you use Claude Code or Cursor to build a new project, the AI defaults to them. The agent makes the architectural decision. The moment we don’t have an active opinion, the AI chooses the best tool for itself.

Your next most important “customer” might not be a person evaluating your landing page. It might be an AI agent evaluating your documentation, your SDK, your API surface. B2A is not a hypothetical. It’s already shaping which companies grow and which ones get skipped.

This leads to a structural prediction: the web is splitting into two parallel layers. Just as SEO emerged to help humans find content through search engines, we’re seeing AEO (Answer Engine Optimization) emerge to help AI agents find, parse and cite content through generative search.

The old layer isn’t going away. But a second one is forming alongside it

HTML is for humans. But increasingly, pages will need a parallel layer in Markdown. It requires fewer tokens, is easier for LLMs to parse, and strips away the visual noise that humans need but machines don’t.

This isn’t just about content. We’ve been watching a version of this pattern for decades in databases: SQL → Postgres → NoSQL, each shift making data more accessible for machines to process at scale. The same thing is happening to the surface layer of the web.

And here’s where it gets interesting: the entire stack is inverting in two directions at once. As natural language becomes the “high-level programming language” (Claude Code, GPT), the actual code underneath may shift lower-level and more token-efficient. Languages like Ruby on Rails, which are more concise per line of logic, might see a renaissance. Not because humans prefer them, but because agents do.

While code moves down the abstraction ladder, prototyping is moving up. And fast. The old product chain used to look something like this:

Idea → PRD → Design brief → Wireframe → Mockup → Prototype → Code → Ship

Each of those steps existed because a human needed to translate intent for another human. The PM wrote the PRD so the designer could understand the vision. The designer made the wireframe so the engineer could understand the layout. The prototype existed so the stakeholder could approve before committing to code.

Now? You describe what you want and get a working product.

We’ve gone from needing 7 intermediate artifacts to needing a conversation. The prototype is the product. The PRD is the prompt.

All those middle layers, the ones that existed to help humans communicate with other humans, are getting compressed because the AI can go from intent to output directly.

Code is getting more machine-efficient. Prototypes are getting more human-accessible. The middle, where humans used to translate for other humans, is disappearing.

This is “speaking into the mic” at the infrastructure level. We no longer need to translate through layers of human intermediaries. We speak into the mic, and the mic builds.

In e-commerce, you'll likely ask your favorite LLM which is the best product for you to buy. Reviews are for LLMs? Your agent will compare prices, check reviews, and negotiate. The storefront becomes an API. The product page matters less than how well your product data is structured for an agent to parse.

In workflows, AI will parse other AIs’ outputs, cutting humans out of most intermediate steps. An AI takes meeting notes, another turns them into tickets, another writes the first draft of the code. The human reviews at the end.

In content, products will optimize not for human clicks but for AI citations. Your blog post’s success will be measured not by pageviews, but by how often it gets surfaced in AI-generated answers.

In product teams, our role is shifting. We’re moving from being the direct audience to being the beneficiary and supervisor. Just as “mobile-first” made us question every desktop-era assumption, “agent-first” will make us question the current ones.

We used to write for humans. Talk for humans. Design for humans. Build products for humans. That made sense for 30 years.

But the ratio is flipping. What started as 100% human-to-human shifted with SEO and social algorithms as machines became the gatekeepers. Now we’re entering a world where most of the interaction chain is machine-to-machine, with the human as the conductor (and sometimes even that get's passed on to the LLM). Setting intent, reviewing output, making the call.

The invisible third participant in every meeting, every document, every product decision... it’s already there. It’s been there for a while. We just hadn’t named it.

We’re all speaking into the mic now. The question is whether you’re building for the audience in the room, or the one that’s actually listening.

Share

AgentCraft - This one just made me smile. It’s an RTS game-style interface for orchestrating AI coding agents. You command, summon and manage agents like you would units in WarCraft. I used to love RTS games as a kid. Maybe the future is having work look more and more like play.

The State of Social Media - Massive Google Slides presentation. I mean massive. If you’re even slightly interested in where social is headed, this is the most comprehensive thing I’ve come across recently. Great quality, worth bookmarking and coming back to.

Anthropic’s Research on AI Labor Market Impacts - ~15 min read. This one took the internet by storm. The gap between what AI can theoretically do and what it’s actually doing is still massive. Claude covers 33% of tasks in computer occupations despite 94% being theoretically feasible. Like anything AI related: short term is overstated, long term is understated.

First Round’s PMF Framework - ~10 min read. They break Product/Market Fit into four progressive levels instead of treating it as binary. If you’re doing 0-to-1 work, this is one of the best resources I’ve seen recently. Really useful for understanding where you are, not just if you’re there.

Stewart Brand’s “Pace Layering” - ~15 min read. From MIT. Brand argues complex systems survive because they have layers moving at different speeds. Fast layers innovate, slow layers stabilize. Replace “civilization” with “product stack” and the human/agent duality clicks into place. One of those reads that quietly rewires how you think.

Thanks once again for reading this far. If you have any questions, think I can help you out, or would like me to address a specific issue… feel free to hit that reply button :)

What did you think of this post? 🤔 Let me know
Amazing Good Meh