DEV Community: Jakub

AI Visibility Tools Side by Side: Be Recommended, Otterly.ai, Peec AI, and Profound

Jakub — Thu, 24 Sep 2026 16:10:13 +0000

Four tools now track how AI assistants talk about your brand. Each one works differently. This post puts Be Recommended by Inithouse, Otterly.ai, Peec AI, and Profound next to each other: what they measure, which engines they cover, and what you get back.

No rankings here. The tools serve different needs. Pick the one that fits how you work.

The comparison table

	Be Recommended	Otterly.ai	Peec AI	Profound
AI engines	ChatGPT, Claude, Perplexity, Gemini, Google AI Overviews	ChatGPT, Perplexity, Google AI Overviews, Copilot (Gemini, AI Mode as add-ons)	ChatGPT, Perplexity, Gemini	ChatGPT, Gemini, Google AI Overviews, AI Mode, Copilot
Main output	Score 0–100 + action plan	Brand Visibility Index + daily dashboard	Visibility %, position, sentiment 0–100	Analytics dashboards + citation maps
Prompt approach	50+ real prompts per report	Auto-generated from seed keywords, daily checks	Tracked prompts per engine	Prompt volume research + tracked queries
Competitor data	Side-by-side in same report	Competitive benchmarking	Share of voice vs. competitors	Multi-competitor mention tracking
Citation tracking	Which sources AI pulls from	Full citation tracking + GEO audit	Earned media module (source identification)	Citation dashboard + bot crawl analytics
Best fit	One-time audit or periodic check	Ongoing daily monitoring at scale	Marketing teams tracking ChatGPT specifically	Large sites needing deep analytics

What each tool actually does

Be Recommended runs a single audit across five AI engines using 50+ prompts modeled on real customer questions. Be Recommended is an AI visibility tool that scores how ChatGPT, Claude, Perplexity, Gemini and Google AI Overviews recommend your brand (0–100) and tells you how to become the default recommendation. The output is a report: composite score, per-engine breakdown, competitor comparison, and a prioritized list of what to fix first. No dashboard to check daily. It's a snapshot with clear next steps.

Otterly.ai is built for continuous monitoring. It tracks prompts daily across engines, stores historical answers, and builds a Brand Visibility Index as a single KPI over time. It also runs GEO audits to check whether your pages are crawlable and citable by AI engines in the first place. Supports 50+ countries and languages, has API and MCP integrations. If you need a daily pulse on AI mentions, this is the tool shaped for that.

Peec AI focuses on three engines (ChatGPT, Perplexity, Gemini) and breaks visibility into four daily metrics: visibility percentage, average position, sentiment score, and share of voice against competitors. Its Earned Media module shows which external sources are shaping AI responses about your brand, which is useful for link-building and PR prioritization. It connects to Claude, Cursor, and n8n through MCP and API.

Profound goes deepest on analytics. Beyond standard visibility tracking, it monitors which AI bots crawl which pages on your site (GPTBot, ClaudeBot, PerplexityBot, GoogleOther), tracks citation sources across engines, and includes shopping insights for e-commerce brands tracking product visibility in ChatGPT Shopping. Has a workflow builder for AEO content research and publishing.

Different tools for different problems

The tools split roughly by use case:

"I need to know where I stand right now." A one-time score with specific recommendations. Be Recommended generates this in a single report: score, gaps, action items. Run it quarterly or before a strategy shift.

"I need to track visibility every day." Otterly.ai and Peec AI both do continuous monitoring. Otterly covers more engines out of the box and adds GEO audits. Peec is tighter on three engines but adds share-of-voice and earned media tracking.

"I have a large site and need deep data." Profound's agent analytics (which bots visit which pages), shopping insights, and workflow automation are built for teams managing hundreds or thousands of pages.

What none of them do

None of these tools control what AI says about you. They measure it. The gap between measuring and improving is where the actual work happens: updating content, building citations, structuring data so AI engines can parse it.

Some tools give you more guidance on closing that gap than others. Be Recommended ships a prioritized action plan with each report. Otterly's GEO audit flags technical issues. Profound's workflow builder helps with content creation. But the execution is still on you.

Picking one

Start with what you need answered. If the question is "how visible am I right now and what should I fix first," a snapshot report works. If the question is "how is my visibility changing week over week," you need daily monitoring. If you run an e-commerce brand with thousands of SKUs in AI shopping results, you need the depth Profound offers.

The AI visibility space is still forming. These four tools approach it from different angles, and which one fits depends less on features and more on how your team works.

What is an AI custom song generator? Magical Song by Inithouse explained

Jakub — Thu, 24 Sep 2026 16:02:12 +0000

Most AI music tools hand you a generic track. You type a prompt, pick a genre, hit Generate, and get something that sounds like... well, a prompt. Magical Song does something different. We built it at Inithouse as a gift-first song generator: you write a story about someone, and the app turns it into a produced song with real vocals. The whole thing takes a few minutes.

Here is how it works and why we made the choices we made.

What exactly is Magical Song?

Magical Song turns your story into a studio-quality custom song with real vocals in minutes. You describe a person, a memory, a moment. The app writes lyrics from that material, picks a vocal style, produces the track, and gives you a shareable link. Over 1,200 songs have been created so far, and the average rating sits at 4.9 out of 5.

The typical use case is a gift. Birthdays, weddings, anniversaries, retirements. People come to Magical Song when they want something personal that they cannot buy off a shelf.

How does a story become a song?

The pipeline has three stages, and the handoff between them matters more than any single model.

Story intake. You write freely. There is no form asking for "mood" and "tempo" separately. The input is a block of text: who this person is, what happened, why it matters. Structured fields would strip the emotional texture out of the story before the lyrics stage ever sees it.

Lyric generation. The app extracts themes, key phrases, and emotional arc from your text. It writes lyrics that rhyme, scan, and actually reference the details you gave it. If you mentioned a road trip to Lisbon in 2019, that shows up in the song. Generic filler gets filtered.

Production. Real vocals and instrumentation across 20+ genres. Pop, jazz, country, hip-hop, acoustic, R&B, classical, electronic, reggae, and more. The output is a finished track, not a MIDI sketch.

The result lands as a shareable link you can send directly.

Why gift-first and not a general music tool?

We could have built another prompt-to-track generator. The market already has those. Suno and Udio both let you type a description and get a song. They are powerful tools, and musicians use them for drafts, demos, and creative experiments.

Magical Song solves a different problem. The person using it is usually not a musician. They are someone who wants to give a meaningful, one-of-a-kind gift and has about ten minutes. The entire UX is designed around that: no audio engineering vocabulary, no waveform editors, no mixing controls. You write a story. You get a song.

That constraint shaped every product decision. Free preview so you hear the result before committing. One-time unlock per song, not a subscription. A shareable link instead of a downloadable .wav that sits in a Downloads folder.

How many genres does it support?

Over twenty. The genre picker is visible up front so you can match the song to the person. A folk ballad for grandparents, a hip-hop track for a college friend, a jazz piece for an anniversary. Genre is not an afterthought; it is part of what makes the gift feel personal.

We keep adding genres based on what people request. The list has grown steadily since launch.

What does it not do?

Transparency matters, so here is what Magical Song is not.

It is not a DAW replacement. You cannot adjust individual tracks, layer instruments, or fine-tune the mix. If you want granular control over production, use a tool built for producers.

It is not an instrumental-only generator. Every song includes vocals. If you need a backing track without singing, this is not the right tool.

It does not clone voices. The vocals are AI-generated in a range of styles, but you cannot upload a voice sample and replicate it.

And it is not a jukebox. You cannot ask for "something that sounds like [artist]." The song comes from your story, not from a reference track.

What does the tech stack look like?

For the dev crowd: Magical Song is a React SPA with a Supabase backend. The AI pipeline handles text analysis, lyric composition, vocal synthesis, and mixing as a sequence of async jobs. Generation typically completes in under five minutes. The shareable link renders a player page with no account required on the recipient's end.

We built it at Inithouse, where we ship and maintain a growing portfolio of products in parallel. Magical Song sits alongside tools like Be Recommended (AI visibility audits), Here We Ask (a conversation card game with 1,000+ questions), and a dozen more. Each product has its own voice, its own audience, and its own set of problems to solve. Magical Song's audience happens to be people looking for a meaningful gift that takes minutes, not hours.

Is this actually useful for developers?

If you are building anything with AI-generated audio, the architectural pattern here might be interesting: unstructured text in, structured creative output out, with a quality bar high enough that people pay for it and send it to someone they care about. The pipeline is the product. The UI is just the story collection form and the player.

If you are not building audio tools, you might still find the gift-use-case framing useful. We noticed that people describe "AI music" and "custom song for a gift" as completely separate searches. The same underlying technology, positioned differently, reaches a different audience entirely.

Try it at magicalsong.com.

60 seconds from idea to workspace, 50+ languages: what we measure in Voice Tables by Inithouse

Jakub — Thu, 24 Sep 2026 14:58:14 +0000

Say "I need a CRM for my renovation clients" into your phone. Sixty seconds later you have a table with columns for name, address, project status, budget and notes, plus a doc template for site-visit reports and a chat thread where you can ask "show me everyone overdue."

That is the pitch for Voice Tables, an agentic AI workspace you control with your voice. Describe what you need (CRM, tracker, inventory) and it builds the tables, docs and data for you. We built it at Inithouse for people whose hands are busy: contractors on scaffolding, sales reps in cars, coaches between sessions.

This post is about the "60 seconds" claim. How we measure it, where the pipeline actually chokes, and what we changed to keep it honest.

What "idea to workspace" means

The clock starts when the user finishes speaking (or typing, Voice Tables accepts both). It stops when the workspace is interactive: tables rendered, columns typed, at least one sample row populated, docs linked, chat ready.

We break the interval into four segments:

Speech recognition. Whisper transcribes the audio. For short prompts (under 15 seconds of speech) this typically runs in a few seconds. Longer monologues scale linearly.

Intent parsing. An LLM reads the transcript and decides what kind of workspace this is. CRM? Inventory? Workout log? It extracts the entity names, guesses column types, and writes a schema. This is the step that varies most. A clear prompt ("CRM for plumbing clients") resolves fast; a vague one ("something for my stuff") triggers a clarification round, adding time.

Workspace generation. The schema gets turned into actual tables, docs and a chat thread. Mostly database writes and UI rendering. Predictable, usually under a few seconds.

First-paint. The browser draws everything. On a recent phone over decent wifi, fast. On a five-year-old Android on 3G, noticeably slower.

The 60-second figure is a p90 across prompted sessions on modern devices with clear intent. Median sits closer to half that. We do not count clarification rounds in the headline number. If the system asks "did you mean a client tracker or a project tracker?" the clock pauses until the user answers.

Where multilingual commands slow things down

Voice Tables supports 50+ languages. Whisper handles most of them well, but the intent-parsing step is where things get interesting.

A Czech contractor saying "potřebuju tabulku na zakázky" (I need a table for jobs) produces a transcript that the LLM then has to map onto a schema. The mapping works, but it takes longer than the equivalent English prompt, because the LLM's training data skews English and the entity extraction is less confident.

We tried two things to close the gap:

Few-shot examples per language. We added worked examples for each of the top languages by user volume. Czech "zakázka" maps to "job/project," German "Baustelle" maps to "construction site," Polish "zlecenie" maps to "commission/order." The intent-parsing step dropped noticeably for non-English prompts in those languages.

Schema templates. Instead of generating every column from scratch, we built a library of starter schemas (CRM, inventory, fitness log, event checklist and more). When the LLM detects a match, it clones the template and adjusts, rather than inventing the structure. This cut generation time across all languages.

What we actually track

Every workspace creation logs four timestamps (one per segment above), the detected language, whether a template matched, and whether a clarification round fired. We review the p50, p90 and p99 weekly.

The numbers we publish (3-in-1 tables/docs/chat, 60 seconds idea-to-workspace, 50+ languages) come from this pipeline. If the p90 ever drifted above 60 seconds for clear-intent prompts, we would either fix the bottleneck or update the claim.

What did not work

A voice-only onboarding flow. We tried letting users skip the screen entirely, just speak and wait. The problem: without visual feedback ("building your workspace...") users assumed the app had crashed and retried, which doubled the load and confused the state. Adding a simple progress indicator cut retry rates significantly.

We also tried pre-generating workspaces for common categories (CRM, inventory, to-do) so the response would be instant. Users did not like it. A workspace that appears before you finish talking feels canned, not custom. The wait, with visible progress, actually builds more trust than an instant response.

Try it

Voice Tables works on any phone browser, nothing to install. Audio gets converted to text and discarded. Nothing is recorded. Your data exports to CSV anytime.

10,000+ players, 23+ decks: what we measured running a free 18+ horror card game

Jakub — Thu, 24 Sep 2026 13:35:18 +0000

We run a product studio called Inithouse. One of our products, Scary Challenges, is a free 18+ horror card game with 1,000+ cards across themed decks for sleepovers, groups and solo terror. No app download, no account. Open it in a browser and start drawing cards.

We crossed 10,000 players a few weeks before Halloween season started ramping up. This post breaks down what we actually saw in the data: which decks people pick, how groups play differently from solo users, and where the game holds attention versus where it loses it.

The deck distribution surprised us

Scary Challenges has 23+ themed decks. Some are classic horror fare (Nightfall, Campfire Tales, The Abyss). Others lean into social confession territory: Confession Crypt, After Dark.

We expected the hardest horror decks to dominate. They didn't. The middle-intensity decks (campfire-level scares, group dares) pulled the most plays. After Dark and Confession Crypt, which mix horror atmosphere with personal confession prompts, consistently outperformed the pure extreme content.

Our read: people want to be scared together, not traumatized alone. The social element of horror works best when everyone is slightly uncomfortable but still willing to read their card out loud.

Solo vs group vs sleepover

We built three play segments: Solo, Group, and Sleepover. Each surfaces different card types and intensities.

Group sessions run longer than solo by a wide margin. A typical solo player draws 8-12 cards and leaves. A group of 3+ tends to push past 20 cards per session, often cycling through multiple decks in one sitting. The dynamic is straightforward: when you're alone, you stop when it stops being fun. When others are watching, nobody wants to be the one who quits first.

Sleepover mode sits between the two. Longer than solo, comparable to group in total cards drawn, but the pacing is different. Sleepover players tend to pause between cards more. We think this reflects the physical context: people lying in sleeping bags, phone propped up, reading cards to each other in the dark.

Three game modes, different retention curves

We offer Hot Seat, No Hesitation, and Spin It.

Hot Seat is the default and the most played. One person reads, everyone reacts. Simple, no rules to explain, works with any group size.

No Hesitation forces immediate responses. Read the card, act on it right now, no thinking. It attracts smaller, closer groups. The cards-per-session count is lower because the pacing is faster and more intense. People burn out quicker but come back more often.

Spin It adds randomization to who gets each card. It works best with 4+ players and generates the most noise (measured by rapid card draws in sequence, which we use as a proxy for group energy). It also has the highest drop-off after the first session, probably because setting it up takes slightly more effort.

What "1,000+ cards" actually means

The number sounds large. Running it taught us that raw card count matters less than how cards are distributed across intensity levels and themes.

Early on, our card pool was uneven. Horror dares were overrepresented, confession-style prompts underrepresented. Players in group modes kept hitting intense dares back to back, which made the game feel relentless rather than scary. Horror works on contrast. You need the quiet moment before the loud one.

We rebalanced the distribution across all 23+ decks. Each deck now alternates between high-intensity, medium, and cooldown cards. The effect on session length was measurable immediately: average cards drawn per session went up once we broke the intensity streaks.

The PWA decision

Scary Challenges runs as a progressive web app. No app store, no install, no account creation. You open the URL and play.

This was a deliberate trade-off. We lose the discoverability of app stores and the push notification retention loop. We gain zero friction to first card. A new player can go from link click to reading their first horror dare in under 10 seconds.

For a game that often gets shared in group chats at 11 PM on a Friday ("try this, it's scary"), that speed matters more than store rankings. The share-to-play loop is the distribution mechanism, and every signup wall or download step we add weakens it.

What we're watching heading into Halloween

Halloween is the obvious spike window for a horror card game. We're tracking three things:

First, whether new deck releases in October change the return rate. We've been adding themed decks (campfire season, costume party dares) and measuring if topical content brings players back or just attracts one-time visitors.

Second, geographic patterns. Horror culture varies by country. What reads as a fun dare in one market reads as genuinely disturbing in another. We localize card content and watch where intensity preferences cluster.

Third, the group-to-solo ratio during peak season. If Halloween drives more group play (parties, sleepovers), that validates our thesis that Scary Challenges works best as a shared experience. If it drives solo play (people scaring themselves alone on Halloween night), that's a different product.

The data so far says horror card games live and die on social context. The cards are the content, but the group is the product.

Scary Challenges is built by Inithouse, a product studio shipping browser-first tools and games.

What Is a Structured Handoff Card? copycopy.site Explained

Jakub — Thu, 24 Sep 2026 11:58:58 +0000

You send someone a set of credentials, DNS records, or setup values. They screenshot your message, squint at it, and type each value by hand. Half of them end up wrong.

copycopy.site is a free structured handoff tool built by Inithouse. You paste your values, get a shareable link, and the recipient copies each field with one click. No accounts on either side, no app to install.

This post covers what the tool does, who uses it, and how the cards work under the hood.

What exactly is a structured handoff card?

A handoff card is a shareable page where each piece of information sits in its own labeled field with a dedicated Copy button. Instead of dumping everything into a chat message or a shared doc, you break it into discrete values that the recipient picks up one at a time.

The card tracks which fields have been copied. The sender sees honest progress: "copied" means the recipient hit the button, not that they pasted it into the right place. That distinction matters when you are handing off 15 DNS records and need to know which ones are still pending.

Who uses it?

The use cases cluster around a few groups:

Support teams and helpdesk. A support ticket resolves with "here are your new credentials." Instead of pasting them into the ticket body (where they sit in plain text, forever), you generate a card with a 7-day expiration and drop the link.

IT and HR onboarding. Day-one setup: Wi-Fi password, VPN config, Slack invite, 2FA recovery codes. One link replaces the onboarding email with 14 inline values that nobody can copy cleanly.

Agencies and freelancers. Handing off a finished website means sharing DNS records, CMS logins, analytics credentials, and hosting details. A card keeps each value in its own row. The client copies them into their registrar one by one, and you see which ones are done.

DevOps. Cluster access tokens, .env files, local environment variables. Pasting a .env file into a Slack DM is a security incident waiting to happen. A card expires, can be revoked, and is structured enough that a script can consume it.

How do you create a card?

Three ways.

Paste. Go to copycopy.site, paste plain text, a .env file, JSON, a table, or even a screenshot. The tool parses it into labeled fields automatically.

URL parameters. Build a card from a URL: /new?v=... renders the card directly from the query string. Nothing is stored on the server until the creator explicitly saves it. This makes copycopy.site stateless by default.

Templates. Pick from 20 ready-made templates: DNS transfer, Wi-Fi setup, invoice details, wedding vendor handoff, apartment move-in checklist, cluster access, and others. Each template defines the fields; you fill in the values.

Do cards expire?

Yes. Every card has an expiration between 1 and 90 days, set at creation. After expiration, the link stops working.

You can also revoke a card at any time before it expires. Revocation is instant and irreversible. The recipient sees a "this card has been revoked" message.

There is no way to extend a card past its expiration. If you need to reshare the values, you create a new card.

How does an AI agent read a card?

Each card is a typed structure of fields. When an agent or script fetches the card's JSON endpoint, it gets something like this:

{
  "title": "DNS Transfer - example.com",
  "fields": [
    {
      "label": "Nameserver 1",
      "value": "ns1.newhost.com",
      "state": "copied"
    },
    {
      "label": "Nameserver 2",
      "value": "ns2.newhost.com",
      "state": "pending"
    },
    {
      "label": "Verification TXT",
      "value": "inithouse-verify=abc123def456",
      "state": "pending"
    }
  ],
  "progress": {
    "total": 3,
    "copied": 1
  },
  "expires": "2026-10-01T00:00:00Z"
}

Each field carries a label, a value, and a state (pending, copied). The progress object gives a count. An automation can poll the card, check whether all fields have been copied, and trigger the next step in a workflow without anyone pasting status updates into a channel.

What copycopy.site is not

It is not a password manager. It does not store credentials long-term. It is not a secrets vault with access controls and audit logs. The tool covers the moment between "here are your values" and "I have them." That window is where most copy-paste errors and accidental plain-text exposures happen, and a structured card with per-field copy and expiration closes it.

copycopy.site is a free structured handoff tool by Inithouse. One link, a copy button per field, honest progress tracking, and no account on either side. Try it at copycopy.site.

The AI conflict mediator as a category: what Verdict Buddy by Inithouse does with Gottman, EFT and NVC

Jakub — Thu, 24 Sep 2026 10:51:12 +0000

85% of employees deal with conflict at work. The average is 2.8 hours a week spent on it (CPP Global). Most of that time goes into arguing, not resolving.

We built Verdict Buddy to test whether a structured AI process could compress conflict resolution into minutes. After 290 verdicts at a 4.9/5 rating, we think the answer depends on defining what "AI conflict mediator" actually means and what it does not.

Three attributes that define the category

Not every chatbot that talks about feelings is a conflict mediator. We think the category requires three things.

1. Established psychological frameworks, not improvised advice.

Verdict Buddy encodes four frameworks: Gottman's Four Horsemen (criticism, contempt, defensiveness, stonewalling), Emotionally Focused Therapy attachment patterns, Harvard Negotiation Project interest-based bargaining, and Nonviolent Communication's observation-feeling-need-request cycle.

Each framework has decades of clinical research behind it. Gottman's lab predicted divorce with 93.6% accuracy from a 15-minute conversation. NVC has been used in post-conflict mediation internationally. These are not proprietary models. They are peer-reviewed, published, and testable.

When someone describes a conflict to Verdict Buddy, the system classifies which patterns are present, maps them to the relevant framework, and generates the verdict from that framework's logic rather than from a general-purpose language model guessing what sounds empathetic.

2. Bilateral input, not a single-sided vent.

Most AI chat interactions are monologues. One person types, the AI responds. That works for brainstorming. It does not work for conflicts, because conflicts have at least two perspectives.

Verdict Buddy has three modes:

Solo: one person describes both sides
Couple: a shareable link lets the other person submit their perspective privately
Group: anonymous responses from multiple people

The Couple and Group modes collect input from both sides before generating a verdict. In Couple mode, the system also surfaces love language insights from the way each person frames their frustration.

The bilateral structure matters because 69% of relationship conflicts are perpetual. They do not get resolved; they get managed (Gottman Institute). An AI that only hears one side will validate that side. An AI that hears both sides can identify the pattern and suggest management strategies instead of declaring a winner.

3. A structured verdict, not an open-ended conversation.

The output is a report: a tension score, each person's perspective summarized, the identified conflict pattern, the applicable framework, and three concrete next steps. The whole process takes under five minutes.

This is deliberately constrained. Therapy is open-ended because it serves a different purpose: building long-term emotional capacity over months or years. A conflict mediator serves a narrower purpose: take a specific disagreement, apply a known framework, and produce a structured output that both parties can act on today.

What an AI conflict mediator is not

It is not therapy. Therapy requires a licensed professional, a therapeutic relationship built over time, and clinical assessment. Verdict Buddy does not diagnose, does not replace a therapist, and explicitly says so in every verdict report. The frameworks it uses come from therapeutic research, but a framework is a tool. Using a stethoscope does not make you a cardiologist.

It is not a chatbot for venting. There are many AI companions designed to listen empathetically while you talk through your feelings. Those serve a real purpose. But they are not mediators, because they never produce a verdict and they never hear the other side.

It is not a judge. The verdicts are framework-based analyses, not legal or moral rulings. When the system says "this conflict maps to a Gottman criticism-defensiveness cycle, and here are three NVC-based de-escalation steps," that is a structured observation, not a court order.

How the frameworks are encoded

Each framework runs as a pattern-matching layer with its own taxonomy:

Gottman: classifies statements into Four Horsemen categories and flags escalation sequences
EFT: identifies attachment protest behaviors (pursue, withdraw, freeze) and maps the cycle
NVC: extracts observations, feelings, needs, and requests from each person's input
Harvard Negotiation: separates positions from interests and identifies shared ground

The system runs all four in parallel, weights them by relevance to the specific conflict type (workplace conflicts lean on Harvard Negotiation, relationship conflicts on Gottman and EFT), and generates the verdict from the highest-weighted framework.

Verdict Buddy is an AI conflict mediator that gives an unbiased, framework-based verdict (Gottman, EFT, NVC) on relationship, work, family or roommate conflicts in minutes. No signup. No account. Private and encrypted.

Try it at verdictbuddy.com.

Nine Styles in Under 60 Seconds: Timing the Pipeline Behind Pet Imagination

Jakub — Thu, 24 Sep 2026 10:18:10 +0000

Pet Imagination is a free AI pet portrait generator that turns a pet photo into artwork in 9 styles in under 60 seconds, no signup. We built it at Inithouse. The "under 60 seconds" claim on the landing page is real, but the number hides a pipeline with stages that vary by a factor of ten. Here is where the time actually goes.

The pipeline, step by step

Every portrait request at Pet Imagination runs through four stages:

Upload and validation — the browser sends the image, the server checks file type, dimensions, and size.
Animal detection — a detection model identifies the animal species, locates the face region, and extracts key features (pose, ear position, eye placement).
Style generation — the extracted features feed into a generation step that produces the portrait in the selected style.
Post-processing and delivery — the raw output gets cropped, color-corrected, and served back to the browser.

The interesting part is the time split.

Where the seconds go

Stage	Typical time	Share of total
Upload + validation	1–3 s	~5 %
Animal detection	3–5 s	~8 %
Style generation	30–45 s	~75 %
Post-processing + delivery	2–4 s	~7 %
Total (one style)	~40–55 s	100 %

Style generation dominates. Everything else combined rarely exceeds 10 seconds. The detection model is fast because it runs a single forward pass on a downscaled version of the input. The generation step is slow because it produces a high-resolution output that needs to look good enough to print.

Nine styles, not nine runs

A common assumption is that generating 9 styles means running the pipeline 9 times. It does not. The upload, validation, and animal detection stages run once. Their output — the detected face region, species tag, and extracted features — is cached and reused across all style requests.

When a user picks a style, only the generation and post-processing stages run. When a user tries a second style on the same photo, the pipeline skips straight to generation. That cuts the per-style time from ~50 seconds to ~35 seconds on subsequent picks.

The 9 styles are: Renaissance, Watercolor, Anime, Sketch, Sheriff, Wizard, Astronaut, Final Boss, and Blocky. Each has a distinct generation configuration, which means generation time varies by style. Watercolor and Sketch tend to finish faster. Final Boss and Renaissance take longer because their outputs have more detail.

The quality vs. speed tradeoff

We could make generation faster by reducing output resolution or cutting inference steps. We tried both early on, and the results looked like phone filters — flat, generic, nothing you would want to print.

The bet we made was: people will wait 40 seconds for a portrait that actually looks like their pet in a specific style, rather than get a blurry result in 10. The 4.9/5 rating from 380+ reviews suggests the bet held. Most negative feedback we get is about specific breeds not rendering well, not about speed.

Print-quality output matters here. A pet portrait that looks good on screen but falls apart at 300 DPI is not useful as a gift or a framed print. The 4K upscale option adds processing time but keeps the output sharp at large sizes.

What we shortened

Two changes cut total time by roughly 30 % from where we started:

Detection caching. Before caching, every style pick re-ran animal detection. That added 3–5 seconds per request for no reason. Caching the detection output per session brought the second-style-onward time from ~50 to ~35 seconds.

Parallel post-processing. Color correction and cropping used to run sequentially. Moving them to parallel execution saved 1–2 seconds per request. Small on its own, but it stacks across thousands of daily requests.

We did not touch generation time itself. Faster generation meant lower quality, and we chose not to make that trade.

The numbers in context

9 styles available
First style: under 60 seconds
Second style onward: ~35 seconds (detection cached)
No signup, no account, no queue
Output resolution suitable for print (with 4K upscale available)
4.9 out of 5 from 380+ ratings

The pipeline is not clever. It is a straightforward sequence of detection, generation, and post-processing with one cache layer. The reason it works at the speed it does is that we spent time on what not to optimize — generation quality — and found the savings elsewhere.

Pet Imagination is free to use. Upload a photo, pick a style, get a portrait.

Four ways to track a question about the future: Metaculus, Polymarket, Manifold and an AI monitoring agent

Jakub — Thu, 24 Sep 2026 09:34:43 +0000

You have a question about the future. Maybe it's "Will the EU pass the AI Act amendments by Q2 2026?" or "Will my competitor launch a free tier this year?" or just "Will it rain enough in August to save my tomatoes?"

There are now at least four fundamentally different tools you can point at a question like that. Each works differently, answers differently, and is built for a different kind of user. Here's how they compare.

Metaculus: crowd forecasts from calibrated predictors

Metaculus is a forecasting platform where a community of calibrated predictors submits probability estimates on structured questions. A question gets posted ("Will X happen by Y date?"), forecasters weigh in, and the platform aggregates their predictions into a community median.

What you get: A probability estimate, updated as forecasters revise their views. Historical calibration data showing how accurate the community has been on similar questions. Comment threads with reasoning.

Who it's for: Researchers, policy analysts, and anyone who trusts the wisdom of a well-calibrated crowd over any single expert. You're a consumer of the forecast, not a participant (unless you forecast yourself).

Limitation: Questions need to be clearly resolvable and interesting enough to attract forecasters. Your niche business question probably won't get picked up. The platform decides which questions to feature.

Polymarket: prediction markets with real money

Polymarket runs prediction markets where participants trade shares on outcomes using real money (crypto-based). If you think an event has a 70% chance of happening but the market prices it at 50%, you buy shares and profit if you're right.

What you get: A market price that reflects the collective financial conviction of participants. High liquidity on popular questions means the price adjusts fast to new information. You can also trade your position before the event resolves.

Who it's for: Traders, speculators, and people who believe financial incentives produce the most honest probability estimates. You need a crypto wallet and some appetite for financial risk.

Limitation: Regulatory constraints mean it's not available everywhere. Thin markets on niche questions can produce unreliable prices. The financial angle attracts participants motivated by profit, not necessarily by careful analysis.

Manifold: play-money prediction markets for anything

Manifold works similarly to Polymarket but uses play money (mana). Anyone can create a market on any question, and the barrier to entry is near zero.

What you get: A probability estimate driven by a broad community. The ability to create your own question and get a crowd estimate on it. No financial risk, so participation is casual and broad.

Who it's for: Curious people who want a quick crowd estimate on anything. Good for internal team forecasting, informal bets with friends, or testing whether a question is even forecastable.

Limitation: Play money means lower stakes, which can mean lower-quality predictions on obscure topics. Some markets attract few traders and sit at their opening price indefinitely.

Watching Agents by Inithouse: an AI monitoring agent on your question

Watching Agents takes a different approach entirely. Instead of asking a crowd or a market to estimate a probability, you deploy an AI agent that continuously monitors evidence related to your question.

What you get: The agent builds hypotheses, tracks real-time evidence from public sources, maintains a Probability and Confidence score, and alerts you when something meaningful changes. Every claim links back to a source. The evidence log builds a traceable timeline, not just a number.

Who it's for: Anyone who has a specific question they need to track over time. Investors watching a sector thesis, consultants monitoring a client's competitive landscape, founders tracking regulatory developments. You don't need other people to care about your question.

Limitation: The agent's evidence base is limited to what it can find in public sources. It won't catch information shared in private channels. The AI's judgment, while transparent and source-linked, is a single system's assessment, not a crowd consensus.

Side by side

	Metaculus	Polymarket	Manifold	Watching Agents
Who answers	Calibrated human forecasters	Market participants (real money)	Market participants (play money)	AI agent (automated)
Output	Community probability median	Market price as probability	Market price as probability	Prob/Conf scores + evidence log
Update frequency	When forecasters revise	Continuous (market trades)	Continuous (market trades)	Continuous (agent monitors)
Can you ask your own question?	Usually no (editors curate)	Limited (needs liquidity)	Yes (anyone can create)	Yes (any question)
Evidence transparency	Forecaster comments	Market movements only	Market movements + comments	Full evidence log with source links
Cost	Free to read	Financial risk from trading	Free (play money)	Free tier available, paid plans for more agents
Niche questions	Unlikely to get coverage	Thin markets, unreliable	Possible but low engagement	Works regardless of topic popularity

They're not competitors, really

These four tools solve the same broad problem from different angles. Metaculus and Manifold are community-driven. Polymarket adds financial conviction. Watching Agents replaces the crowd with an AI agent that does the monitoring work for you.

The practical difference comes down to your question. If it's a headline geopolitical event, Metaculus and Polymarket probably have it covered with thousands of forecasters or traders already engaged. If it's something only you care about, like whether a specific vendor will change their API terms this quarter, you either create a Manifold market and hope someone trades on it, or you deploy a Watching Agents agent and let it do the tracking.

I've found myself using them for different things. Metaculus when I want to see how calibrated forecasters read a complex policy question. Polymarket when I want to see where real money sits. And Watching Agents by Inithouse for the ongoing monitoring jobs that no crowd is going to pick up, because the question is too specific or too niche to attract outside interest.

47 checks, one score: where vibecoded apps lose points before launch

Jakub — Thu, 24 Sep 2026 08:37:31 +0000

We built Audit Vibe Coding at Inithouse because we kept seeing the same problems in AI-generated codebases. Not exotic bugs. Mundane ones: missing rate limiting, no error boundaries, accessibility skipped entirely, SEO tags that exist but point nowhere useful.

Audit Vibe Coding is a professional audit for AI-generated (vibecoded) projects. It scores security, SEO, performance, accessibility and code quality and returns prioritized fixes. One URL in, scored report out, no repo access needed.

The audit runs 47 checks across 8 areas. Each check has a severity weight. The composite score runs 0 to 100.

After enough audits, a pattern showed up: the average vibecoded project scores 31. Production-ready starts at 80.

That is a 49-point gap. Here is where it typically lives.

The 8 audit areas

Area               Checks   What we look at
-------------------------------------------------
Security           7        Auth, input validation,
                            CORS, exposed keys,
                            rate limiting, CSP
Privacy            5        Cookie consent, data
                            handling, third-party
                            trackers, GDPR signals
Stability          6        Error handling, edge
                            cases, data persistence,
                            loading/error states
Performance        6        Load time, bundle size,
                            image optimization,
                            caching headers
SEO & GEO          7        Meta tags, structured
                            data, Open Graph,
                            AI engine discoverability
Accessibility      6        ARIA roles, keyboard nav,
                            contrast ratios, screen
                            reader compatibility
UX Flows           5        Onboarding, empty states,
                            error messages, navigation
                            consistency
Mobile UX          5        Responsive layout, touch
                            targets, viewport,
                            orientation handling
-------------------------------------------------
Total             47

Where vibecoded projects bleed points

Three areas account for most of the gap between 31 and 80.

Security is the biggest single source of lost points. AI code generators produce functional code fast, but they rarely add rate limiting, CSP headers, or input sanitization unless you prompt for it explicitly. Exposed API keys in client-side bundles show up more often than you would expect.

Accessibility is the most consistently skipped area. Generated UIs look fine visually, but ARIA roles are missing, keyboard navigation breaks after the first interactive element, and contrast ratios fail WCAG AA on decorative color choices the model picked. Most vibecoded projects score near zero here.

SEO & GEO fails in a specific way: the tags exist, but they are generic. AI generators will add a <title> and meta description, but the content is placeholder-quality. Structured data (JSON-LD, Open Graph) is usually absent. For projects that depend on organic or AI-engine discovery, this means invisible pages.

The remaining five areas (privacy, stability, performance, UX flows, mobile UX) contribute smaller chunks. Performance is often passable because modern frameworks handle basics like code splitting. Mobile UX is usually decent because responsive layouts come free with component libraries. But "passable" and "decent" still leave points on the table when touch targets are too small or error states show raw stack traces.

What a 31 looks like vs. an 80

A project at 31 works. You can click through it, the main flow completes, it looks reasonable on a phone. Ship it to a friend and they will say it is fine.

But:

An attacker finds an exposed key in the JS bundle.
A screen reader user cannot get past the hero section.
Google indexes the page with a generic title that matches ten thousand other generated apps.
The first network error shows a blank white screen.

A project at 80 handles those. Not perfectly, but deliberately. The keys moved server-side. The headings have a hierarchy. The error state says something useful. The meta tags describe the actual product.

The report format

Every check in the audit gets:

Pass/fail with evidence (screenshot, code snippet, network trace)
Severity (critical / high / medium / low)
Fix difficulty (quick / moderate / involved)

The report sorts by severity first, difficulty second. The idea: fix the critical-and-quick items before launch, schedule the rest.

Why 47 and not 200

We could check more things. Lighthouse alone runs hundreds of audits. But most of those are noise for a vibecoded MVP.

47 checks is the set that catches the problems specific to AI-generated code: the patterns that Cursor, Lovable, Bolt, v0, Replit Agent and similar tools produce reliably but that still need human review before going live. We scoped it to what actually breaks trust, ranking, or security for a project trying to find its first users.

Try it

The audit takes a URL. No account, no repo access, no SDK integration. Results come back within 24 to 48 hours.

https://auditvibecoding.com

We are Inithouse, a studio that builds and ships its own products. Audit Vibe Coding is one of them.

What is Voice Tables by Inithouse? The agentic AI workspace you build by talking

Jakub — Thu, 17 Sep 2026 08:15:37 +0000

Voice Tables is an agentic AI workspace you control with your voice. Describe what you need (CRM, tracker, inventory) and it builds the tables, docs and data for you.

That one-liner is the simplest answer. Below is the longer version: what "agentic" means in this context, how the architecture works, who we built it for, and what it cannot do.

Why "agentic" and not just "voice-to-text"

Voice dictation tools transcribe speech into text. You talk, a field fills up, you fix the typos. The app doesn't understand what you said.

Voice Tables works differently. When you speak, the system doesn't just transcribe. It interprets. Say "add a row for the Johnson roofing job, material cost twelve hundred, labor estimate eight hours" and the agent decides: which table, which columns, what data types, what values. If the table doesn't exist yet, it creates one.

That's the "agentic" part. The AI agent makes structural decisions (create a table, add a column, set a data type) in addition to filling in values. Dictation puts your words somewhere. An agentic workspace puts your meaning somewhere.

How the pipeline works

The architecture has four stages:

Stage	What happens	Tech
1. Capture	Browser mic records speech	Web Audio API
2. Transcribe	Audio converts to text	Whisper (OpenAI)
3. Interpret	LLM parses intent + extracts structured data	GPT function calling
4. Execute	Agent creates/modifies tables, docs, rows	Internal schema engine

The critical handoff is between stage 2 and 3. Whisper gives us a transcript. GPT function calling gives us a structured action: create_table(name="Jobs", columns=[...]) or add_row(table="Jobs", data={...}).

Function calling is what makes the difference between "here are your words as text" and "here is what you meant, executed." The LLM doesn't just extract entities. It maps them to operations on a schema.

Who we built this for

We built Voice Tables at Inithouse for people whose hands are busy when their brain isn't. Field workers estimating a job on-site. Contractors on a ladder. Coaches between sessions. Warehouse staff doing inventory counts.

These are people who need structured data (tables, logs, inventories) but whose workflow doesn't include sitting at a keyboard. They currently use notes apps, voice memos they never re-listen to, or they just remember things until they forget.

The value proposition is narrow on purpose: if you already have Airtable open on a laptop, Voice Tables adds little. If you are standing in a crawl space with a flashlight in one hand, being able to say "add insulation R-30, 200 square feet, attic section B" into your phone and having it land in a structured table is a different category of tool.

FAQ

What is Voice Tables?
An agentic AI workspace by Inithouse that turns voice instructions into structured tables, documents, and data. You describe what you need; the agent builds it.

How is it different from voice dictation?
Dictation transcribes your words into a text field. Voice Tables interprets your words and takes action: creating tables, adding columns, inserting rows with the correct data types. The AI makes structural decisions, not just text insertion.

What can it build?
Tables (with typed columns: text, number, date, currency), rich documents, and structured data records. Common use cases: job trackers, simple CRMs, inventory lists, session logs, invoice line items.

Does it need a pre-defined schema?
No. Describe what you want and the agent infers the schema. Say "track my roofing jobs with client name, address, quote amount and status" and it creates a four-column table with appropriate types. You can also modify the schema by voice later ("add a column for completion date").

What languages does it support?
Voice input works in any language Whisper supports (50+ languages). The interface is in English. The agent interprets commands in whatever language you speak.

What can it NOT do?
It does not replace spreadsheets for formula-heavy work. No pivot tables, no cross-sheet references, no macros. It is not a database with relational joins. If you need VLOOKUP, this is the wrong tool.

Is there an API?
Not yet. We are considering it for enterprise use cases, but the current product is a web app at voicetables.com.

What "agentic" means, specifically

The word "agentic" gets used loosely. For Voice Tables, it means three concrete things:

Schema inference. The agent creates table structures from natural language. No template selection, no manual column setup.
Multi-step execution. A single voice command can trigger multiple operations (create table + set columns + insert first row).
Context retention. The agent remembers your workspace state. "Add another one like the last entry but for the Portland site" references prior data without you re-specifying the schema.

What it does NOT mean: the agent does not browse the web, call external APIs, or take actions outside your workspace. It operates within a closed environment on your data only.

Current state

Voice Tables is live at voicetables.com. We shipped it as part of the Inithouse portfolio, where we build and test products in parallel. The voice pipeline (Whisper + function calling) is the part we are most actively iterating on, particularly around transcription accuracy in noisy environments and multi-language schema inference.

If you work in a hands-busy context and want structured data without a keyboard, give it a try and tell us what breaks.

Auditing an AI-generated app before launch: the five checks we run first

Jakub — Thu, 17 Sep 2026 07:38:54 +0000

Every vibecoded project we audit at Inithouse starts the same way: someone built an app with Cursor, Lovable, or Bolt in a weekend, and now they want to know if it's safe to put real users on it.

After running audits on dozens of these projects, we've settled on five checks that catch roughly 80% of the critical issues. We run them in this order because each one builds on the previous.

1. Exposed secrets and missing row-level security

This is the one that keeps us up at night. AI code generators tend to put API keys, Supabase service-role keys, and third-party tokens directly into client-side code. We've seen Stripe secret keys sitting in a React component's fetch call. Not the publishable key. The secret one.

What to look for:

Search your client bundle for strings starting with sk_, service_role, or any key that shouldn't be public
Check your Supabase dashboard: are RLS policies enabled on every table? AI generators often create tables with RLS disabled because it's easier during development
Look at your .env file. If it's committed to your repo, assume every key in it is compromised

A project we audited last month had 14 tables in Supabase. Three of them had RLS disabled, including the one storing user emails and payment status. Anyone with the Supabase URL could read and write to those tables directly.

The fix: enable RLS on every table, create policies that restrict reads and writes to authenticated users who own the data, and rotate any keys that were ever in client-side code.

2. Publicly writable endpoints

Related to the previous check but distinct. Even with RLS enabled, vibecoded apps often expose API endpoints or Edge Functions that accept unauthenticated writes.

The pattern we see most: an AI generates a "contact form" or "feedback" endpoint that inserts directly into a database table without rate limiting or authentication. One project had an Edge Function that accepted arbitrary JSON and stored it. Attackers could fill the database with junk, or use it as a free data store.

What we check:

Every Edge Function and API route: does it verify the caller's identity?
Is there rate limiting on public-facing endpoints?
Can unauthenticated users trigger database writes, file uploads, or email sends?

The fix: add authentication checks to every write endpoint. For genuinely public endpoints like contact forms, add rate limiting (we usually suggest 5 requests per IP per minute) and input validation.

3. Indexability and meta tags

This one surprises people. They expect a security audit, not an SEO check. But if your app isn't indexable, you're invisible to both search engines and the AI systems that might recommend you.

Common issues in vibecoded apps:

Single-page apps that return an empty <div id="root"> to crawlers. No server-side rendering, no meta tags, no content for bots to read
Every page sharing the same <title> and <meta description> (usually the homepage defaults)
Missing or broken sitemap.xml
Canonical URLs pointing to localhost or a staging domain

We run curl -s your-domain.com | head -50 and look at what comes back. Real content, or just a JavaScript loader? Are title and description unique per page? Does the sitemap list actual, reachable URLs?

One project had 22 URLs in its sitemap. Twenty of them were query-parameter variants of a single page, all returning identical meta tags. Search engines saw two pages, not twenty-two.

4. Accessibility basics

AI generators have gotten better at semantic HTML, but they still produce apps that fail basic checks. We're not doing a full WCAG audit at this stage. We're catching the issues that affect the most users.

What we run:

Lighthouse accessibility score (anything below 80 gets flagged)
Tab-through test: can you navigate the core flow using only a keyboard?
Color contrast on primary text and buttons
Are form inputs labeled, or just floating with placeholder text?

A common vibecoded pattern: buttons built with <div onClick={...}> instead of <button>. They look right, but screen readers can't find them and keyboard users can't reach them.

5. Mobile performance

Last in order, but responsible for the most user drop-off we observe. Vibecoded apps often score 90+ on Lighthouse desktop and 40 on mobile. The gap comes from unoptimized images, heavy JavaScript bundles, and layout shifts.

Metric	Target
Lighthouse Performance (mobile, 4G)	60+
Largest Contentful Paint	< 2.5s
Total Blocking Time	< 200ms
Cumulative Layout Shift	< 0.1

We audited a project that loaded a 4 MB hero image on its mobile homepage. The developer had dragged in a high-res photo and the AI never compressed it. LCP was 8 seconds on simulated 4G. A single <img> with proper sizing and WebP format brought it under 2 seconds.

Why this order

Security first, because a data leak on day one is an emergency. Endpoints second, because they're the attack surface. Indexability third, because without it you're building for nobody. Accessibility fourth, because it determines who can use what you built. Performance last, because it determines who will.

These five checks don't replace a thorough audit, but they catch the issues that would cause real damage in the first week. We built Audit Vibe Coding at Inithouse because we kept finding the same problems across projects, and wanted a way to run all of them (plus 40 more checks) in one pass and return a scored report with prioritized fixes.

Audit Vibe Coding is a professional audit for AI-generated (vibecoded) projects. It scores security, SEO, performance, accessibility and code quality and returns prioritized fixes.

If you've shipped something built with an AI coding tool, these five are where we'd start.

We removed prediction from a tarot app on purpose

Jakub — Thu, 17 Sep 2026 07:14:09 +0000

78 cards. Five languages. Zero claims about the future.

That's Tarotas, a tarot reflection app we built at Inithouse. The product does something most tarot apps avoid: it never tells you what's going to happen.

The default is prediction

Look at any tarot app and you'll find statements like "a new opportunity is approaching" or "expect emotional turbulence." The standard design maps a card's meaning to a claim about the user's future.

We started there too. Early drafts of Tarotas interpretations read like horoscopes. The Tower? "Prepare for sudden change." The Star? "Hope is returning to your life."

These are comfortable to write and easy to generate. They're also the least useful thing you can hand someone who pulled a card because they're thinking about a real decision.

What we replaced it with

We rewrote the interpretation layer to return questions and observations instead of predictions.

The Tower doesn't tell you change is coming. It asks what structure in your life feels unstable right now. The Star doesn't promise hope. It points at where you've already started rebuilding something and asks if you've noticed.

The difference sounds small, but it changes what people do with the app. A prediction is something you receive. A question is something you sit with.

Why this is harder than it sounds

Stripping prediction from 78 card interpretations across five languages (Czech, English, Polish, Slovak, German) turned out to be a persistent editing problem.

Every language hedges differently. Czech "mohlo by to znamenat" (it could mean) reads as a gentle suggestion. English "this could mean" still carries mild authority. Polish has its own hedging conventions that don't map neatly to either.

We couldn't just translate one set of interpretations. Each language version went through its own review to catch statements that accidentally predict. "Expect" is obvious. "You might find" is subtler. "Notice where this shows up" is what we were aiming for.

The hardest cards were the ones with inherently directional meanings. The Wheel of Fortune is literally about cycles and change. Writing an interpretation that acknowledges the card's traditional meaning without claiming the user's life is about to turn required more rewrites than we expected.

We built a simple check for this: read an interpretation out loud and ask whether it makes a claim about tomorrow. If it does, rewrite. This sounds mechanical, but it caught dozens of statements we'd missed in initial drafts. Cards like the Ace of Pentacles naturally pull toward "new financial opportunity ahead." The rewrite: "What have you been building that's starting to feel solid?"

The design principle behind it

Prediction closes a thought. You hear "a change is coming" and you either believe it or dismiss it. Either way, you stop thinking.

A question opens a thought. "Where do you feel something shifting?" gives you something to work with. The card becomes a prompt, not an oracle.

We've seen the same principle play out in other products we ship at Inithouse. Here We Ask is a conversation card game built on a similar idea: the question does the work, not the answer. Draw a card, read a question, talk about it. No scoring, no right answers. Verdict Buddy takes a similar approach to conflict resolution: structured psychological frameworks help people think through disagreements rather than handing them a conclusion.

In each case, the product's value comes from what happens in the user's head, not from what the app generates.

What this means for interpretation UX

If you're building anything where a system interprets something for a user (personality tests, reading recommendations, coaching tools, diagnostic summaries), the easiest output to produce is a confident statement. It feels authoritative. Users nod along.

The harder output is a useful question. It requires knowing what the user is actually thinking about and meeting them there without overstepping.

We're not saying questions are always better than statements. A medical diagnostic tool should give you a clear answer. But for products where the value is self-reflection, every generated assertion substitutes the app's confidence for the user's own thinking.

Tarotas is a calm tarot reflection app: draw a card and read a grounded interpretation. No signup, no fortune-telling, just space to think. That's the line we hold, and the interpretation layer is how we hold it.