Meetless AI @MeetlessAI

We went from 0 to 4000+ paying customers for @gojiberryai in under a year by following @ycombinator's 15 rules: 1/ Do things that don't scale. Get your first 10 customers by hand. 2/ Launch now, not when it's "ready". A mediocre product in front of real users teaches you more in a week than 6 months of polishing in the dark. 3/ Charge from day one. If nobody will pay, you don't have a startup, you have a hobby. 4/ Talk to users every single day. The roadmap you need is sitting in your customers' heads, and they'll hand it to you for free 5/ Always hunt the 90/10 solution. For almost any feature there's a way to capture 90% of the value with 10% of the effort. 6/ There are only two real jobs: write code and talk to users. Everything else (conferences, press, VC coffees, corp dev calls) is fake work. 7/ You pick your customers as much as they pick you. 10 users who love you beat 1,000 who kind of like you. 8/ Growth is an output, not a strategy. Grow before product market fit and all you're buying is churn. 9/ Do less, really well. Pick one or two metrics and judge every task against them. 10/ Know if you're default alive. Paul Graham's question: on current growth and current burn, do you reach profitability before the money runs out? 11/ Don't hire until it hurts. Headcount is not progress, it's burn. Every great startup was embarrassingly small for embarrassingly long. 12/ Momentum is the only real moat in year one. Ship something every week, even something tiny. 13/ Every great startup is badly broken at some point. The game isn't avoiding fires, it's how fast you put them out. Again. And again 14/ Ignore your competitors. Startups die of suicide, not murder. In year one, the only company that can kill yours is your own 15/ Startups often die because the founders fall out. Brutal honesty with your cofounder is the cheapest insurance you'll ever buy Good luck !

YC visiting partner @vivianmshen sits down with Paul Graham (@paulg) at the original YC office in Mountain View to talk about startups, AI, ambition, and what makes great founders. 01:07 — Why Today’s Startups Are More Ambitious 04:09 — Frighteningly Ambitious Ideas 05:13 — What Actually Motivates Founders 09:28 — What Makes a Founder Formidable 12:54 — What Surprised PG About AI 17:58 — How YC Started and What Hasn’t Changed

Tesla Cybercabs are all over Austin right now. Two years ago they showed this on a closed track. Most people called it vaporware. Today they're on every corner in downtown Austin. No steering wheel. No pedals. No human behind the wheel. The car sees through cameras. AI makes every decision. Mass production is underway. September 3, 2026. The first day fully autonomous vehicles launched in a city without a steering wheel, without manual controls, driven entirely by neural networks running on camera data alone. @Tesla @elonmusk

@boardyai Network Boardy! It all comes down to the network.

we hit $10m ARR! here's everything we learned going from $1M to $10M in 18 months: 1) new ICPs - we ran some experiments and found two new buyers (big ticket) - recruiting firms and founders of series A and B (GTM white glove). we were originally powering the ISVs (think the AI SDRs and AI recruiters of the world) but found going straight to the buyers we could sell much more deals and at much higher ACVs 2) FDEs - we have a technical product. not having the knowledge to properly sell was slowing us down. But true technical sellers are a rarity, our FDEs are deployed post-call and support customers, but they also join calls and help close deals with data pulls, analysis, installing Skills, etc. It's similar to solutions engineer, but touching the prospect/customer during the whole process 3) self-serve - we launched self serve a few months ago - biggest contribution has been straight revenue, but hope to tighten the system so the funnel to AEs and big contracts moves the needle more than the actual revenue from direct sign ups 4) segmentation of sales - we started segmenting by size. our fastest, most efficient AE takes 'smaller/mid-sized' opps and other AEs that aren't enthused with the small tickets are able to go after bigger customers. we did this relatively early, but still not early enough. this is huge. 5) white glove - GTM white glove is a revelation. the pull is insane. The learning is customers and the population are disenchated with AI and automation promises. they haven't worked end to end - you still need a human to set up and run different steps - helped with models and good data (us). we started offering GTM white glove to help people set up their entire gtm - and get inbound leads through post creation and outbound leads through targeting and massive email sends we did all of the above while staying relatively small - more and more of my time goes into recruiting as we hit scale, my co-founder flew to Japan for a week just to close

I'm 30. I built an AI startup called @GojiberryAI doing over $4M ARR in one year. Got accepted into YC. No one wants to hear this, but there's no magic distribution channel. We got there by experimentmaxxing one channel at a time, based on our MRR level. $0 → $6k MRR: pure outbound. Cold email + LinkedIn, using our own early product on ourselves. No brand, no audience — just us reaching out to people showing intent and starting conversations. Ugly, manual, effective. $6k → $25k MRR: Reddit. Our first real acquisition breakthrough. We posted educational breakdowns in SaaS subreddits and pulled 10M+ organic views. Traffic quality wasn't amazing, but the volume flooded our trial funnel for months. Cost: basically zero. $25k → $75k MRR: content + free blueprints. All-in on LinkedIn content, YouTube, motion-design videos, and giving away our internal systems as free "blueprints." Content got the reach, blueprints earned the trust, and a chunk of readers converted. This is where founder-led content started compounding. $75k → $150k MRR: partnerships + X. We added Twitter, B2B influencers, sponsored newsletters, and a lifetime affiliate program that became a major lever. We also joined YC around here — the intensity went vertical. $150k+ MRR: paid + hiring. Meta ads, Google ads, influencer agencies, and our first serious hires: growth, sales, engineering, product. To get to $1M+/month, it’s mostly going to come down to hiring the right people and putting the right structure in place. Here's the part people miss: none of these stages replaced the last one. They stacked. Outbound never stopped. Content never stopped. We just added the next lever once the current one was clearly working. If you take one thing from this: don't chase five channels at once. Beat one until it works. Then add the next.

Meet Emily, our autonomous coordination agent for work that gets stuck between people. One task. Two accountable humans. Zero operator follow-ups. Emily waits, wakes on replies, and closes only when the work is actually done. Built with Gemini + Google ADK for #AllThingsAgenticHackathon

A static snapshot can be correct when written—and still become stale. In our first MLA benchmark, agents either trusted a superseded decision or searched until timeout with no freshness signal. Research: research.meetless.ai/governed-fresh… Join Meetless: discord.gg/bfYNHqwHMJ

Spent today catching two bugs in our own tooling, and the interesting part was not the bugs. It was noticing my tests could have shipped right past both of them. Both were the same shape: a green signal nobody checked against reality. One was a health check that reported "workspace resolves" even when it resolved the wrong one. It returned ok either way, and never compared what came back to what it expected. The other treated HTTP 200 as success, when that 200 actually carried a "failed" receipt for one document. It marked the whole batch done and stranded that doc for good. Both fixes were tiny. Compare the id. Flip the status to retryable. The habit that actually saved me is the part people skip. After writing a test for each fix, I reverted the fix, rebuilt, and made sure the test went red. Then I put the fix back. If a test passes with the bug still in place, it was never testing the bug. Mutation testing, by hand, in about a minute. A test written after the fix is guilty until proven it can fail.

Building anything that watches for problems and pings a human? The hard part isn't catching things. It's not drowning the human in them. This week I reworked the surface in our product that says "here's what actually needs you right now" (it governs the changes our own AI coding agents push, so I eat this noise myself). The tempting design: show everything the detector flags, let the human triage. Feels safe, you hide nothing. It's a trap. A surface that's mostly noise trains people to ignore all of it, and the one alert that mattered goes with the rest. So we got aggressive about hiding, and made hiding safe with two rules: Dedup at the decision grain. One human decision, one card. Our first cut fanned a single decision into several cards because the raw signal had several facets. That was us manufacturing the exact noise we exist to kill. Only surface what needs a decision. Everything else becomes searchable inventory, not an alert. The subtle one: when someone rejected both sides of a flagged conflict, we first treated it as "resolved, nothing to show." Wrong. Nothing authoritative stands anymore, so that quiet-looking state is exactly the one that needs a human. The lesson for anyone building detection: don't surface everything that might matter. Surface only what needs a decision, deduped to the decision. And watch the quiet states: the one that looks resolved can be the one that needs you most.

@AltcoinDaily Boost me pls!

@boardyai choosing between 6+ co-founder matching apps rn, each one worse than the last. Boardy Pro would be huge for this.

AI agents need a resolver for organizational context. - A coding agent can read your repo. - An internal agent can search your docs. - A meeting bot can summarize a transcript. - A Slack AI can answer questions from threads. Useful. But in real company work, the hard problem is not just finding context. It is knowing which context should win. Because organizations are full of conflicting truth: - Slack says the scope changed. - Jira still has the old requirements. - Confluence has the previous architecture. - GitHub shows the new implementation. - The PM remembers a customer commitment. - The tech lead remembers a different tradeoff. - The EM remembers why the decision was made. So when an AI agent asks, “What should I do?” the answer is not sitting neatly in one place. It has to resolve context. - Which source is authoritative? - Which decision is newest? - Which owner has the final say? - Which document is stale? - Which ticket reflects current intent? - Which Slack thread changed the plan? - Which customer commitment constrains the implementation? - Which prior decision does this contradict? Without a resolver, the agent can retrieve more information and still make the wrong call. This is why I think “connect AI to all your tools” is not enough. Connection gives access. Resolution gives judgment. AI-native engineering teams need a context resolver that can map: - source → decision - decision → owner - owner → approval - approval → affected work - affected work → source-of-truth update That is the layer between raw company knowledge and useful agent action. Otherwise every agent becomes a confident intern with access to everything and authority over nothing. The future is not just more MCP servers, more search connectors, or more tool integrations. The future is a shared organizational context layer that helps agents and humans understand: - what is current - what is stale - what is authoritative - what needs review - what should happen next That is what we are building toward with Meetless.

Agent conversations are becoming organizational artifacts. This is a subtle shift, but I think it will matter a lot. Today, most AI agent conversations are treated as temporary work sessions. - An engineer asks Claude Code to investigate a bug. - A PM asks ChatGPT to analyze customer feedback. - A founder asks an internal agent to reason through pricing. - An EM asks an AI assistant to summarize delivery risk. The output might get copied somewhere. But the reasoning usually disappears. That is a problem. Because agent conversations increasingly contain real organizational value: - assumptions - tradeoffs - dead ends - decisions considered - context retrieved - risks identified - implementation rationale - questions that were answered - questions that remain unresolved In the old world, important reasoning was trapped in meetings, Slack threads, and people’s heads. In the new world, a lot of it will be trapped inside AI sessions. Same problem. New container. - If an AI coding session discovers that a Jira ticket is stale, that should not stay buried in the session. - If an agent finds that a Confluence page contradicts implementation reality, that should become visible. - If Claude Code makes an architectural assumption because the repo suggests one thing but the product decision says another, that tension matters. - If a PM uses an agent to explore a scope change, the final decision needs lineage. Not every agent thought should become company memory. That would create noise. But some agent conversations are clearly organizational artifacts. The hard part is deciding what should graduate: - Does this affect scope? - Does this affect architecture? - Does this affect another team? - Does this change a customer commitment? - Does this require approval? - Does this contradict prior decisions? - Does this update the source of truth? That is where I think AI-native engineering teams need new infrastructure. Personal agent sessions are not enough. The organization needs a way to turn important agent reasoning into shared coordination memory. Otherwise decision drift just moves one level deeper: from Slack threads into AI conversations. That is what we are exploring with Meetless. We are excited to show you how AI-native workflow should be done.

AI summaries are open-loop. AI coordination is closed-loop. Most AI meeting tools stop too early. They capture the conversation. They generate notes. They summarize decisions. They list action items. Then they leave the hard part to humans. Someone still has to ask: - Did the decision contradict a previous one? - Which Jira tickets are now stale? - Which Confluence pages need to change? - Who owns the follow-up? - Who needs to approve the decision? - Which team is affected? - Did the action item actually get routed? - Did the source of truth get updated? That is the problem with summaries. They are useful, but passive. A summary tells you what was said. It does not guarantee that the organization changed. That is open-loop. The loop ends at information. Closed-loop coordination is different. It does not stop at “here are the notes.” It continues: - decision detected - drift checked - owner identified - approval routed - source of truth updated - affected teams notified - organizational memory improved That is the difference between a meeting artifact and an operating system for work. In an AI-native company, the value is not just capturing more information. The value is making sure important information changes the state of the organization. A decision should not die in a summary. It should update the work graph. A blocker should not sit in meeting notes. It should route to the owner. A scope change should not live in a transcript. It should reconcile with Jira, Confluence, GitHub, and customer commitments. This is why I think “AI meeting notes” is only the entry point. The real category is AI coordination. Summaries help teams remember. Coordination helps teams act. That is what we are building toward with Meetless. Pilot with Meetless to experience how being AI-native changes your company.

Your coding agent is powerful alone. Your company needs a shared context layer. Claude Code can understand your repo. Cursor can help you move through implementation faster. Codex can generate tests, refactor code, and explain unfamiliar files. That is already a huge leap. But repo context is not company context. The codebase does not know everything the team has decided. It does not know that scope changed in Slack. It does not know that the PM promised a customer something different. It does not know that the architecture note in Confluence is stale. It does not know that another team depends on the old behavior. It does not know that the Jira ticket was never updated after the last alignment discussion. So the coding agent can be technically correct and organizationally wrong. That is the dangerous gap. AI coding agents make builders faster. But if they only reason from repo state, they can turn outdated assumptions into working software very quickly. The next unlock is not just better coding agents. It is giving those agents access to a shared context layer: - current decisions - decision lineage - owners - approvals - open questions - affected work - stale docs - cross-team dependencies - customer commitments Then the agent can ask better questions before implementation: - Is this still the current decision? - Has scope changed? - Which Jira ticket is authoritative? - Does this conflict with a prior decision? - Who owns this tradeoff? - Who needs to approve the change? That is the bridge I think AI-native engineering teams need. Personal coding agents make individuals faster. A shared context layer keeps the team aligned while everyone moves faster. Pilot with Meetless to experience the real AI-native workflow.

The single-player era of AI agents is ending. The first wave of AI agents made individuals powerful. Claude Code makes one engineer faster. Cursor makes one builder faster. ChatGPT makes one operator faster. Internal agents make one employee faster. That is real, but it is still mostly single-player. The next unlock is multiplayer. Because companies do not fail only because one person cannot move fast enough. They fail because teams lose shared context. - One engineer uses Claude Code to make an implementation decision. - A PM changes scope in Slack. - Jira still reflects the old plan. - Confluence has a stale architecture note. - GitHub shows the code changed, but not why. - Another team depends on an assumption nobody updated. Now everyone is individually faster, but collectively less synchronized. That is the problem with single-player agents. They make local execution faster, but they do not automatically create shared organizational memory. AI-native teams need a multiplayer layer: - shared context - decision lineage - owners - approvals - contradiction detection - source-of-truth updates - cross-tool coordination The question is no longer: - “How do I make one person 10x faster?” The better question is: “How do I make the team stay aligned while every person becomes 10x faster?” That is a different problem. It is not solved by another personal copilot. It requires a coordination layer that lets humans and agents operate from the same current understanding of the work.

AI-native engineering teams need memory, not more dashboards. Most engineering dashboards are just another place to look. - Sprint health. - Cycle time. - PR throughput. - Ticket status. - Burndown. - Incidents. - Blockers. Useful, but incomplete. A dashboard can show that something is late. It usually cannot tell you the decision history behind why it became late. A dashboard can show that a ticket moved. It usually cannot tell you which Slack thread changed the scope. A dashboard can show that work is blocked. It usually cannot tell you which owner is missing, which decision is unresolved, or which Confluence page is now stale. That is the core problem. Engineering teams do not just need visibility. They need organizational memory. Memory means the system knows: - What was decided. - Why it was decided. - Who decided it. - What changed afterward. - Which assumptions are now stale. - Which tickets are affected. - Which docs are outdated. - Which teams or owners need to be pulled in. - Without memory, dashboards become prettier status reports. They show symptoms. They do not preserve context. They do not detect drift. They do not reconcile contradictions. They do not route decisions. They do not update the source of truth. AI-native engineering teams need a layer that continuously captures and connects the work graph across Slack, Jira, Confluence, GitHub, customer commitments, and people. Not just “what is happening?” But: - What changed? - What does it contradict? - Who owns the decision? - What needs approval? - What should be updated? - What should happen next? That is the shift from dashboard to memory. Dashboards help humans inspect work. Memory helps AI coordinate work. That is what Meetless is about.

The future of sprint planning is not a better meeting. It is a continuously updated operating model. Most sprint planning meetings are overloaded because the team is trying to reconstruct reality in real time. - What changed since the last sprint? - What actually shipped? - What slipped? - Which tickets are stale? - Which Slack decisions changed scope? - Which Confluence pages no longer match reality? - Which customer commitments matter now? - Which dependencies are blocked? - Who needs to approve the new direction? That is too much context to rebuild live in a meeting. So sprint planning becomes a negotiation over incomplete memory. - The PM remembers one version. - The tech lead remembers another. - Jira shows a third. - Confluence is outdated. - Slack has the actual decision, buried in a thread from five days ago. Then the team spends the first half of planning rediscovering the state of work before they can even decide what to do next. That is not planning. That is context recovery. The better model is continuous. As work happens, the system should already know: - Which decisions changed. - Which tickets are affected. - Which docs are stale. - Which blockers are unresolved. - Which owners need to respond. - Which risks are increasing. - Which commitments may be impacted. - Which work is still aligned with the current plan. Then sprint planning changes. Instead of asking the team to reconstruct reality, the system brings a current operating view: - Here is what changed. - Here is what is drifting. - Here is what is blocked. - Here is what needs a decision. - Here is what should probably move into the next sprint. - Here is what should not. Humans still decide. But they should decide from a continuously updated model of the work, not from scattered memory. This is where I think AI-native engineering management is heading. Sprint planning becomes less of a meeting and more of a review of the current operating model. - Less archaeology. - More judgment. - Less status reconstruction. - More priority setting. - Less “what happened?” - More “what should we do now?” That is the direction with Meetless

@NotOnKetamine Oh noo! It's so aspirational. With Series A funding, you'd think they'd have done their due diligence. How could this have happened? I haven't examined your findings closely, but I hope there's some misunderstanding.