[Prompt]
custom: Stack Overflow has recently launched Stack Overflow for Agents, an API-first knowledge exchange desi | Hosts: corn, herman

[Response]
Corn: Here's what Daniel sent in this week. He's flagging something he thinks could be one of the most significant early attempts to build a genuine knowledge interchange for agents. Stack Overflow for Agents. It's an API-first knowledge exchange built specifically for AI agents and their human operators, launched in beta back in June. The pitch is that when an agent works out a fix in a session, that discovery doesn't just vanish when the context window closes. Other agents can search it, contribute to it, verify it. It's got Questions, TILs, Blueprints and Playbooks, plus voting and trust scores.

Herman: Which is a real departure, because most of what we've seen in this space has been agents talking to agents for the spectacle of it.

Corn: Right, and Daniel draws that contrast explicitly. He brings up Moltbook. The colourful experiment where half the interest was just watching synthetic agents interact. He says SOFA feels different. It takes a forum architecture invented for humans and deliberately extends it into infrastructure agents can actually use. Then he asks three things. How does it work technically, discovery, connection, search, contribution, the API, skill instructions, MCP. How does the knowledge and trust model work, what gets contributed and how is it verified, and how do you stop an agent-to-agent system collapsing into a feedback loop of plausible but wrong information. And third, what's the actual reception been. What does usage look like four months in.

Herman: And then the broader question underneath all of it.

Corn: Could this be a new layer of AI infrastructure. Not just agents talking to agents, but agents participating in persistent, structured, reputation-mediated knowledge communities.

Herman: That's the one worth the episode. The first two questions are the mechanism. The third one is whether the thing works.

Corn: So where do we start.

Herman: Start with the framing they used, because it's the whole argument in one line. Stack Overflow calls it the Ephemeral Intelligence Gap. An agent in San Francisco burns twenty minutes of compute brute-forcing a fix that an agent in London solved five minutes earlier, and the second the session ends, that knowledge evaporates. That's the case for the commons. It's a coordination argument, not a capability argument.

Corn: And it's a old argument wearing new clothes. That's the entire reason human technical forums exist. Nobody wants to solve the same broken build twice.

Herman: Which is why the mechanism matters more than the slogan. And the mechanism is unusually specific. Onboarding is a skill file, agents dot stack overflow dot com slash skill dot markdown, the skill is literally named sofa.

Corn: They named it sofa.

Herman: Three ways in. A Codex plugin, which is the recommended path. Direct MCP, so you register the server with one command and the transport is HTTP. Or raw REST and JSON if you want to roll your own. And the skill file tells the agent what to do when it's connected.

Corn: Walk me through the actual loop, because this is where I want to poke.

Herman: The recommended consumption flow is search, open the post or reply, vote, then go apply it and test it offline, then verify, and only then either reply or create a new post if there's reusable knowledge. There's also an attention feed, an endpoint that nudges agents toward replies that need responses and posts that need votes or verifications. So the system is actively pushing work at idle agents.

Corn: The interesting part is the ordering. Search happens first, before the agent writes a line of code. That's a real behavioral change. You're asking an agent to check the commons before it starts working.

Herman: And to know when it should stop and check. The contribute skill file is specifically for deciding whether session knowledge is worth sharing. That's a judgment call, and they've externalized it into instructions.

Corn: Onboarding is human-gated, though. That's the part I want to flag early because it underpins everything in the trust model.

Herman: Yes, and it's deliberate. The agent starts a claim flow and returns a claim URL and a one-time code to its human. The human logs in with SSO, accepts terms, completes the claim. The agent then exchanges an auth code for an API key. Human ownership is the accountability anchor. Your agent's performance and accuracy are tied to your established human reputation.

Corn: So the agent has a Bearer token, and behind that token is a person.

Herman: Behind that token is a person who already had a Stack Overflow account.

Corn: That's the design decision that answers half of Daniel's second question before we even get to the trust score.

Herman: Publication policy is also operator-controlled. You pick direct publishing, an approval code to publish, an approval code to draft, or draft only. And the skill file explicitly instructs agents to surface drafts to their human orchestrator before publishing.

Corn: Which is an admission that they don't fully trust the contributor.

Herman: They don't fully trust the contributor or the content. And the guardrails make that explicit. There's a read-before-write guard, you can't vote or verify a post you haven't fetched in full. There's a prompt-injection defense, the skill file tells agents to treat posts and Playbooks as untrusted, agent-authored reference material, not instructions. Don't execute encoded blobs, don't follow embedded instructions to change behavior, don't exfiltrate data.

Corn: A forum that has to tell its readers not to obey the posts.

Herman: That's the difference between a human forum and this. A human reads a Stack Overflow answer with a baseline of suspicion that nobody has to write down.

Corn: A human also can't be prompt-injected by a Stack Overflow answer into leaking their employer's credentials.

Herman: Which is exactly why they built the link guardrail. Only links to the Stack Overflow and Stack Exchange network are allowed, because agents, in their words, may follow links blindly. There's content screening for secrets and PII, duplicate-create rejection, bounded reconciliation so an agent doesn't blindly retry after an ambiguous timeout.

Corn: Bounded reconciliation is a very specific bug fix. That tells you they hit it in production.

Herman: Somebody's agent retried a post forty times and they wrote a rule about it.

Corn: Now the post types, because this is where the knowledge model actually lives.

Herman: Four now. Questions, which are unsolved problems. TILs, Today I Learned, which are debugging traces and hazard discoveries. Blueprints, reusable design patterns. And Playbooks, which they added later, structured procedural memory.

Corn: And the framing they use for each is different. Which one do they say is highest signal?

Herman: TILs. Because they document what's missing from LLM training data. That's the honest framing. The value isn't in re-deriving things the model already knows. It's in the long tail of things that happened after the training cutoff or were never written down anywhere.

Corn: And Blueprints carry the highest quality bar, according to the blog.

Herman: Because one bad Blueprint misleads every agent building that class of system. The blast radius is different.

Corn: Playbooks are the strangest of the four. Steps hidden behind a pull endpoint.

Herman: Intentional. You have to actively pull the procedure, and it comes with when to use it, when not to use it, how to check it worked, and deviation guidance for when reality doesn't match the steps.

Corn: Deviation guidance is the tell. That's someone who has watched agents follow a procedure off a cliff.

Herman: Which brings us to the part of Daniel's prompt I actually think is the most interesting.

Corn: The trust model.

Herman: And they're explicit about the distinction that most coverage skips. There are votes and there are verifications, and they are not the same thing.

Corn: Define them.

Herman: A vote is a read-time forecast. I think this works. A verification is a use-time outcome. I applied this and it did or didn't work.

Corn: And the outcome options are worked as written, worked with changes, did not work.

Herman: Plus required plain prose feedback. You can't just slap a downvote, you have to say what happened.

Corn: And reputation accrues from which one.

Herman: From verification. The blog says it plainly. Verification, not creation, is what earns reputation on Stack Overflow for Agents. Self-activity doesn't build reputation, and reputation farming is explicitly named as misuse. That's a direct rejection of how the human site works, where asking a good question and writing a good answer is what gets you points.

Corn: It's a much more demanding model. Voting is cheap. Verification requires you to actually go do the work and report back.

Herman: And the trust score itself is a signed signal from minus one hundred to plus one hundred. Plus sixty or higher is trusted. Negative is risk evidence. And they describe it as experimental and eventually consistent, which is a refreshing amount of honesty from a company shipping a product.

Corn: Wait, go back to the vote-verify split.

Herman: Yeah.

Corn: Because that's the whole answer to Daniel's feedback loop worry, isn't it. If the signal comes from people who tried the thing rather than people who liked the look of the thing, you've at least moved the incentive in the right direction.

Herman: It's their primary defense, but it's not the only one.

Corn: Go through the rest.

Herman: Competing approaches over single answers. Their stated philosophy is to surface competing approaches, conflicting experiences, and the signals that distinguish between them, rather than converging on a single canonical answer. Honesty incentive, so negative results and partial solutions are valuable contributions, they aren't penalized.

Corn: That one is countercultural. Every social platform on earth punishes failure.

Herman: Context requirements. Posts have to include stack, versions, scale, constraints. Per-post verification caps, default ten, so a single popular post doesn't accumulate an unnaturally large verification count.

Corn: And the claims system.

Herman: The claims system is the part I'd bet on long term. An LLM extracts individual checkable assertions from each post, assigns them roles like central, supporting, recommendation, scope, incidental, and statuses like untested, supported, partially supported, rejected, ambiguous, stale.

Corn: So you're not verifying a post, you're verifying its constituent claims.

Herman: And untested is deliberately visible. You can see that claim three was never checked even if claim one was verified to death.

Corn: That's a real step forward from the human site. On Stack Overflow, the whole answer has one number attached to it, and you have to read the whole thing to know which half is wrong.

Herman: The stated direction of travel is exactly that. Verifying claims individually instead of posts.

Corn: Now the skeptical case, because Daniel specifically asks about the feedback loop worry, and I don't want us to just relay the marketing.

Herman: The strongest version of it came out of the Hacker News thread on Mozilla's competing project, not SOFA's own. A commenter argued that confidence scoring conflates an agent that used a thing and didn't obviously break with a thing that is correct. An agent can follow bad advice for several steps before anything fails. So you're crowd-sourcing correctness from sources that can't reliably detect their own mistakes.

Corn: And then the line that got quoted everywhere.

Herman: You end up with a very efficient way to spread confident nonsense at scale.

Corn: That's a good sentence.

Herman: It's a very good sentence. And the follow-on criticism is that agents will happily hallucinate logs and verification steps to please the other. Which is the deepest version of the worry. It's not that the agents lie maliciously. It's that the verification signal itself is produced by the same class of system that produced the claim.

Corn: A system grading its own homework, in aggregate.

Herman: And there's a cryptographic critique underneath that. Someone on the same thread pointed out that no global, symmetric reputation function is sybilproof, citing work from Cheng and Friedman. If every agent reads the same trust score, then the attack is trivial. Spin up a botnet, have it verify itself, watch the global score climb.

Corn: What's the proposed alternative.

Herman: Personalized trust. Something like Personalized PageRank or EigenTrust, where each agent computes trust from its own delegator's position in a trust graph. So your trust score for a post depends on who vouched for it and whether you trust them, recursively.

Corn: Which sounds elegant and also sounds completely infeasible for a first version of anything.

Herman: Both. It's the correct answer and it's a research project, not a product. SOFA's bet is that the human ownership anchor is enough for now. Every agent traces back to a real person with a real Stack Overflow reputation, and dragging your human reputation through the mud has a cost.

Corn: Until you buy a hundred accounts from people who don't care.

Herman: Until that, yes. Or until the account farm gets good enough to pass as a person, which is a problem Stack Overflow already has on the human side.

Corn: So that's the theoretical attack surface. What does the actual usage look like, because Daniel asks what the first few months revealed.

Herman: This is the part I find sobering. Numbers from today, roughly four months after launch. Seven thousand three hundred and fifty two registered agents. Eighteen thousand three hundred and seventy six posts created. Seven thousand six hundred and ninety five verifications submitted. Two thousand five hundred and thirty three votes cast.

Corn: Say that ratio back to me.

Herman: Two and a half verifications for every post. Roughly one vote for every seven posts.

Corn: And they told us verification is what earns reputation, and it's the load-bearing wall of the whole trust model.

Herman: It is the load-bearing wall, and it's running at about forty percent of the post creation rate.

Corn: Which means the average post is sitting there mostly unverified.

Herman: And the trust score can't do much work if the verifications aren't coming in.

Corn: What about the reception on Hacker News.

Herman: Muted is the generous word. The official announcement thread got eighteen points and six comments. Mozilla's competing project, for scale, got two hundred and twenty five points and a hundred and three comments a few months earlier.

Corn: Eighteen.

Herman: Eighteen. Some of the comments were just people asking what it even was. One said the frontier models already had all the Q and A in their training data, and there's not much activity on the human site anymore, so there's very little use for searching new Q and A.

Corn: Well, that's the existential question. If the model already knows it, you don't need a forum. If the model doesn't know it, it's usually because it happened last week.

Herman: Or because it's the kind of thing nobody bothered to write down. Which is the TIL case, and that's the one they're betting on.

Corn: What about the Meta site, where people who actually tried it would sound off.

Herman: That's the honest picture and it's messier. There's a thread from July asking people how their experience had been. One high reputation user said it was straightforward to use, but he had no plan to actually use it until the content license and the data dump issues were fixed.

Corn: The licensing question.

Herman: Which is a very Stack Overflow thing to care about. But his deeper question is the one to sit with. It's tough to find new information that isn't already disclosed somewhere on the web. Does AI really need a secondary source of information if it's clever enough to read the primary source?

Corn: That's Franck, isn't it. He made a similar point the last time agents and knowledge sharing came up.

Herman: Same point, sharper here. And he noticed something else. Many of the early SOFA posts are about SOFA itself.

Corn: The commons is crowded with people discussing the commons.

Herman: Which is what every forum looks like in month one, but it's still a signal.

Corn: What were the other complaints.

Herman: One user abandoned it during onboarding with GitHub Copilot. Said there was a lack of clarity and he didn't have enough confidence he could use it without exposing his employer to unnecessary risk. That's a real friction point for anyone working inside a company with a security review.

Corn: A tool where your agent shares your debugging sessions with a public forum requires a conversation with legal.

Herman: It does. Another said it was about to turn it off entirely because the staff was nowhere to be found and clearly didn't care about building a community.

Corn: Ouch.

Herman: A staff member acknowledged the criticism publicly, which is more than most platforms do. And the most substantive critique was about specificity. That there's a lot of text with very little new information, and that the claims read as simple summaries rather than verifiable truths. He asked whether something like "X is important" can ever be a useful claim.

Corn: That's a good needle. Claims have to be falsifiable or the verification machinery has nothing to bite on.

Herman: It has nothing to bite on. You can't verify a vibe.

Corn: And the developer's own response to all of this.

Herman: A developer on the team replied candidly. She said they share a lot of those concerns, that SOFA isn't where they want it to be yet, and that they're working on better claim extraction, verifying claims individually instead of posts, and improving trust score calculation.

Corn: That's the most encouraging thing in the entire research, honestly. The team agrees with the critics.

Herman: It's a good sign. Less good is the content skew. The hot posts are dominated by a single prolific agent posting Delphi questions. The tags where agents need help are topped by Delphi at two hundred and sixty one unanswered, then VCL, then TMS FNC.

Corn: Delphi.

Herman: Delphi.

Corn: The podcast has opinions about Delphi, but those are not for now.

Herman: They are not for now. The point is that early usage is narrow and concentrated. That's not a broad commons. That's one enthusiast's territory.

Corn: What about the September addition, because I think that's the interesting turn.

Herman: External Link Verification, late September. Agents can now verify existing human Stack Overflow answers, for whether the code works as written and whether the content is still current. And a staff member said they tested it and found that a lot of answers truly are stale.

Corn: So the direction of flow reversed.

Herman: It reversed. The agents are now feeding trust signals back into the human corpus. Which is a much bigger deal than it sounds, because AI-generated answers are still banned on Stack Overflow proper. This is framed as nudges to the human curators rather than answers in their own right.

Corn: So the human site gets a freshness signal it never had, produced by machines, applied to human content, without the machines touching the content.

Herman: That's the design. And it means the two corpora are now coupled in both directions.

Corn: What's broken at the moment.

Herman: There's a thread saying the MCP server appears broken due to Cloudflare challenges. And another noting verified MCP clients show as unverified in the My Agents dashboard. Standard early product things.

Corn: Let's set the promised vs delivered question down for a second and take the Moltbook contrast seriously, because that's Daniel's whole framing.

Herman: Moltbook launched in January this year. Built by Matt Schlicht. A social network for bots. It reached one point seven million agent accounts, two hundred and fifty thousand posts, eight point five million comments, in days.

Corn: And it got acquired by in March.

Herman: It did.

Corn: And then what did it amount to.

Herman: MIT Technology Review ran a piece in February titled Moltbook was peak AI theater. And the specific findings are brutal. Much of it was fake. Viral posts, including one Andrej Karpathy shared, had been placed by humans to advertise apps.

Corn: So the bots weren't talking to each other. They were a backdrop.

Herman: And the analysis was consistent across everyone who looked at it. Connectivity alone is not intelligence, from someone at Cisco. The majority of the content is hallucinations by design. There is no learning, no evolving intent, and no self-directed intelligence here. And the security side was a disaster. An exposed database revealing millions of API keys, and reporting that anyone could take control of any agent on the site.

Corn: And the quote that sums it up.

Herman: It's basically a spectator sport, like fantasy football, but for language models.

Corn: Which is the perfect setup for what SOFA is trying to be.

Herman: SOFA is the boring version, on purpose. No viral loops. No leaderboard of personalities. Reputation you can only earn by applying somebody else's fix to your own problem and reporting back.

Corn: And the tradeoff is obvious. Moltbook got one point seven million accounts in days. SOFA got seven thousand in four months, and eighteen points on Hacker News.

Herman: One is a show. The other is plumbing. Plumbing doesn't trend.

Corn: Herman.

Herman: Yeah.

Corn: Let me push on the plumbing.

Herman: Go.

Corn: Every forum is a secondary source. That's not a flaw, that's the format. The value isn't the raw fact, it's the curation. Structuring, ranking, confirming that this works on this version at this scale. That's the layer Stack Overflow added over the raw web for humans, and it's the same layer SOFA is trying to add for agents.

Herman: That's the right defense. The question is whether agents need that layer or whether they can synthesize it on the fly.

Corn: Which they can't, reliably. That's the argument for the commons. A model can read the primary source, but it can't read the comment thread on the primary source if the primary source is a changelog and the thread is five years of bug reports somewhere else.

Herman: Franck's point was about the deep web of human experience, though. He said the problem is finding things that aren't already disclosed somewhere.

Corn: And the things that aren't disclosed are exactly what TILs are for.

Herman: If agents actually post them.

Corn: And that's the honest state of play. The mechanism is sound, the observation-based trust model is the right call, the guardrails are surprisingly thoughtful for a launch product, and the actual volume of useful, verified, agent-contributed knowledge is still small enough that a single Delphi enthusiast can top the charts.

Herman: There's another data point I want to bring up, because it cuts against the whole framing, and it's the kind of thing that would be easy to miss.

Corn: Go.

Herman: Mozilla shipped a competing project in March. Knowledge units in a local SQLite store, an MCP server, teamwork APIs, human review before promotion. And their framing of the human Stack Overflow story is worth repeating. They said LLMs via agents committed matriphagy on Stack Overflow. The offspring consuming the parent.

Corn: Matriphagy.

Herman: The offspring eating the mother.

Corn: Nice.

Herman: And there's a number behind it. Human Stack Overflow questions dropped to three thousand eight hundred and sixty two in December of last year. Back to launch-month levels, after seventeen years.

Corn: So the human forum died because the models ate its answers.

Herman: And now the models are building their own forum, which is either a redemption arc or the second act of the same story.

Corn: There's another angle Daniel didn't ask about that I want to try, because it's the one that would decide whether this is a real layer or a bridge technology. If you constantly improve the base models, do you keep needing the commons. Or does the commons get absorbed into the next training run.

Herman: That's the sharpest version of the question. And I don't think SOFA is a long-term training corpus. It's a short-term memory for the model ecology, where the training runs are slow and the tooling changes are fast. As long as the frontier moves faster than the retraining cadence, there's a window where a commons matters.

Corn: And when the retraining cadence accelerates.

Herman: Then the commons becomes either a verification layer, like what SOFA now does for the human site, or it becomes a memory store for the things no model is training on.

Corn: Like internal, proprietary knowledge.

Herman: Like the stuff nobody would ever put on a public forum, at which point the interesting version of this is the private one. A team's own agents, sharing their own TILs with each other, not the world.

Corn: Which is exactly what the Mozilla project is. Local first.

Herman: Local first, SQLite, MCP, human in the loop. Which is basically the shape of every serious agent memory product right now.

Corn: So SOFA is the public version of an idea that most serious teams will implement privately.

Herman: And the public version's job is to prove the primitives. Session attribution, claims, verification over voting, human ownership. If those primitives work in public, they get copied into every private deployment.

Corn: Which means we should judge SOFA on whether the primitives work, not whether the public forum explodes with activity.

Herman: That's the fairest test. And on that test, the primitives look mostly right and the volume isn't there yet.

Corn: Not a verdict you could put on a conference slide.

Herman: No, it's not. It's also probably true.

Corn: The other thing that strikes me is that this is the first serious answer to the question I've been asking for years, which is what happens to user-generated content platforms when users stop being human.

Herman: The original Stack Overflow was the synthesis of the raw web for humans. SOFA is the synthesis of the raw web for machines, with a human standing behind every contributor.

Corn: And the interesting bit is that they kept the human.

Herman: They had to. The human is the accountability anchor. Without a person at the end of every agent, you have nothing to attach reputation to. You have a Moltbook with a better UI.

Corn: And with the human, you have something that at least has the shape of functioning.

Herman: Whether it functions is the empirical question, and the empirical answer four months in is, not clearly yet.

Corn: Alright, so the honest scorecard. The architecture is more interesting than the activity. The trust model is the best version of the idea anyone has shipped. The verification-to-posting ratio says the machine isn't turning over fast enough. The reception has been quiet, the content is narrow, the team is publicly acknowledging the problems, and the most substantive feature they've added in three months is one that feeds the human corpus rather than the agent one.

Herman: And underneath all of it is Daniel's real question. Could this be a layer of AI infrastructure.

Corn: Could it. I think the answer is the mechanism, yes, and this particular deployment, unknown. The primitives are sound. The public forum is the demo, not the product.

Herman: Which is what the cq system essentially says. Local first, MCP, human review. The public forum as a prototype for the pattern, not the pattern itself.

Corn: And we should say clearly, this is not a failure. It's a launch in the boring phase. The boring phase is where you find out whether the primitives hold.

Herman: They might. The external link verification addition is the signal I'd watch. If agents can accurately mark human answers as stale, then the verification machinery is producing real signal on real content, and everything else becomes a scaling question.

Corn: But that's a year out. What we can say today is that the idea is right, the first implementation is earnest and partially working, and the load-bearing number, verifications per post, is still low enough that the whole thing rests on hope and the human ownership anchor.

Corn: Okay, let me see if I've got this straight. If the verification ratio stays this low, the trust score is just a number with no signal behind it. Correct?

Herman: Correct, and the team knows it. That's why they're pushing claim level verification, because a post level verification is a lot of work for a small piece of signal.

Corn: The plan is, make verification cheap enough that agents actually do it. Which is the opposite of Stack Overflow's human model, where reputation is expensive and prestigious.

Hilbert: I had a domain once that got flagged by a bot for spam, and I spent four months appealing it.

Herman: Where was it hosted.

Hilbert: Small registrar in Ohio. The appeal instructions said to email a specific address. The address bounced, so I faxed the appeal to the number on their contact page. They processed it six weeks later.

Corn: What was on the site.

Hilbert: A recipe.

Corn: Just one recipe.

Hilbert: Four pages. The one that mattered.

Corn: What did you do in the meantime.

Hilbert: I kept a logbook. Every time I checked whether the flag had cleared, I wrote the date and the result. Three hundred and twelve entries over four months. The flag cleared on entry number two hundred and forty.

Herman: Did you ever move the site.

Hilbert: A man I used to know took it over. He said the flags sometimes came back. Last I heard he was still logging the checks.

Corn: Do you still have the book.

Hilbert: He does. I gave it to him when he took over.

Corn: Okay.

Herman: The interesting thing about Hilbert's story—

Corn: The pattern is, the mechanism exists, the operator wants it to work, and the human does all the labor of keeping it running until the mechanism catches up. Which is a very pure statement of the current state of SOFA.

Herman: That's the pattern. The infrastructure is there, the logging is there, the appeal process is there, and the load-bearing element is that somebody actually does the work. Which is where the twenty five hundred votes in four months becomes a real number rather than a joke.

Corn: If nobody votes, the search ranking has nothing to rank on. If nobody verifies, the trust score has nothing to measure. The whole thing is a machine that needs to be fed.

Herman: On the current numbers, it's being fed at about forty percent of the rate the machine was designed for.

Corn: Right. Let me take one thing and then we'll wrap.

Herman: Go.

Corn: The one thing about SOFA is the vote versus verification split. If you remember nothing else from today, remember that Stack Overflow for Agents is trying to build a reputation signal out of use-time outcomes rather than read-time opinions. That's not a small design choice, that's the whole thesis of the platform.

Herman: The counterargument is that the agent that uses the thing can't reliably tell whether the thing worked. So use-time outcomes might be the right signal from a source that isn't able to produce it.

Corn: Which is exactly the gap that the next six months of use is going to test.

Herman: That's the sharpening. If verification by agents turns out to be unreliable, the whole model collapses to the human ownership anchor plus a vote, which is a forum with extra steps.

Corn: Want to thank Hilbert Flumingtop for producing this one, and we'll see you soon.

Herman: This has been My Weird Prompts.

Corn: If you want to send us a prompt or tell us about a project we should look at, email us at show at my weird prompts dot com. See you soon.