DEV Community: Jakub

copycopy.site by Inithouse: structured handoff cards you can generate from a URL, with JSON for agents

Jakub — Sun, 06 Sep 2026 13:19:37 +0000

Twenty ready-made handoffs, three ways to build a card, and one link where every value has its own copy button. That is copycopy.site, a free structured handoff tool we built at Inithouse. You paste logins, DNS records, an invoice or a screenshot, share one link, and watch honest progress as the recipient copies each field. No account is needed on either side.

The interesting part for developers is not the editor. It is that a card can be generated straight from a URL, with nothing stored on our side, and read as JSON by an agent.

The unit is a field, not a message

Chat picks the message as its unit: a blob of text the recipient scans and retypes. Secret-sharing tools pick the secret: one value, one view, then it burns.

copycopy.site picks the field. A field is a label, a value, a required flag, an optional note and a state. A card is fields grouped into sections. Every field gets its own copy button, so a CNAME with a trailing space stops being a two-day thread.

What that changes against the usual options

What a handoff needs	Chat message	One-time secret link	copycopy.site
Copy one value without selecting text	Manual selection	Whole blob at once	Copy button per field
Multiple values in one place	Yes, unstructured	Usually one secret	Fields grouped into sections
Sender sees what was taken	No	View count only	Progress per field
Account needed	Both sides	Sender usually	Neither side
Expiry and revocation	No	Burn on read	1 to 90 days, revoke any time
Machine-readable	No	No	JSON: label, value, state

Cards from a URL, with nothing stored

The route is /new and it takes four query parameters:

v: the values in Label: value format, one per line (newline as %0A)
title: card title, optional
purpose: a one-line note under the title, optional
expires: days until expiry, 1 to 90, applied only if the card is saved

Encoded, a DNS handoff is one line:

https://copycopy.site/new?v=CNAME%3A%20www%20-%3E%20proxy.example.com%0AA%3A%20203.0.113.10&title=DNS%20for%20client&purpose=Point%20the%20domain

Open it and the card renders with two fields, two copy buttons and a progress line reading "0 of 2 required copied". The page states what happened on the server, which is nothing: the card lives only in the link.

Generating one from a ticket system is a few lines:

const values = { Ticket: "REQ-2026-0417", Customer: "ACME-4471", Plan: "Pro" };
const v = Object.entries(values).map(([k, val]) => `${k}: ${val}`).join("\n");
const url = `https://copycopy.site/new?${new URLSearchParams({
  v, title: "Support handoff", purpose: "Generated from the ticket system"
})}`;

No API key, no signup, no rate limit to think about, because nothing is called on the server. Saving the card is a separate step, and it is what gives you the share link, the expiry and the tracking. The 20 templates at copycopy.site/examples cover the same ground for people who would rather start from DNS verification, cluster access or employee onboarding than build a URL.

Honest states: copied is not pasted is not completed

Clicking Copy proves the value reached the clipboard. It does not prove the value landed in the registrar's DNS panel. So copycopy.site tracks those separately and both sides see the same progress view. That distinction removes the one message every handoff thread contains: "did you get it?".

Machine-readable by design

Every card is a plain structure of typed fields, and that structure is what an agent reads:

{
  "card": "hc-8f3c",
  "items": [
    { "label": "API KEY", "value": "pk_live_8f3c9a2d4b71", "state": "copied" },
    { "label": "WEBHOOK URL", "value": "https://hooks.example.net", "state": "pending" }
  ],
  "progress": "2/4"
}

An onboarding agent does not click a button to get the webhook URL. It reads items[1].value and the state moves, while the human on the other side sees the same progress bar.

That decision comes from what we keep measuring at Be Recommended, our AI visibility tool: assistants pick up what is structured and skip what is only rendered. Building a handoff tool as a pretty page would have contradicted our own data.

When to use which

One-off values, nothing to track: build a /new URL, send it, nothing is stored.
Values that need tracking, expiry or revocation: save the card and share the link.
A tool or agent on the receiving end: save the card and point it at the JSON.
A single secret that must self-destruct after one view: that is still a one-time-secret tool, not this.

copycopy.site is free, runs in the browser, and needs no signup from the sender or the recipient. We build it at Inithouse, a studio shipping a growing portfolio of AI products and custom agents. Other tools from the studio include Be Recommended, which scores how ChatGPT, Claude, Perplexity and Gemini recommend a brand, and Here We Ask, a free browser conversation card game with 1,000+ questions that also runs with no account.

Origin Of You by Inithouse next to a personality quiz: 120+ data points and a written portrait instead of a type

Jakub — Fri, 04 Sep 2026 11:39:17 +0000

Five systems, 120+ data points, one written portrait. That is what we feed into Origin Of You every time someone finishes the questionnaire. No four-letter code, no color bucket. A paragraph-length text that holds the contradictions most typologies smooth away.

We built Origin Of You at Inithouse after watching how people actually use personality quizzes. They take the test, screenshot the result, share the label, and forget about it within a week. The label sticks, but the nuance never lands.

Two approaches, same starting question

Both a quiz and a portrait start from the same place: tell me about yourself. Where they diverge is what comes back.

A personality quiz maps your answers to a pre-built category. You are one of 16 types, or one of 9 enneagram numbers, or a specific archetype. The output is a label. Concise, shareable, easy to remember.

A written portrait works differently. Origin Of You pulls from five frameworks (MBTI-style cognitive functions, enneagram, astrology via natal chart, human design, and numerology), collects 120+ individual data points, and synthesizes them into free-form text. The output is not a type. It is a description of how those systems overlap, contradict, and reinforce each other for one specific person.

Where a quiz wins

Quizzes are genuinely better at certain jobs:

Speed. A quiz takes 5-10 minutes. Origin Of You asks for birth data across five systems. It takes longer to complete.
Shareability. "I'm an INTJ" fits in a bio. A two-page portrait does not.
Community. Type-based communities exist (r/INFP has 200K+ members). Portrait-based communities do not, because each portrait is unique.
First contact. When someone has never thought about personality frameworks, a simple type is a useful starting point.

We do not pretend Origin Of You replaces quizzes for these use cases. If you want a quick label for your dating profile, a quiz is the right tool.

Where a quiz drops the signal

The same simplicity that makes quizzes shareable also makes them lossy. Here is what we kept running into during research:

What you want to know	What a quiz gives you	What a portrait gives you
How your thinking style interacts with your emotional patterns	A type that covers one axis	A paragraph mapping where cognition and emotion reinforce or clash
Whether your career instincts align with your relational patterns	Two separate type results (if you take two tests)	A single text integrating work and relationship drivers
What happens when two of your frameworks contradict each other	Nothing, each quiz is siloed	An explicit call-out: "Your enneagram pulls toward X, but your chart suggests Y"
How your patterns shift under stress vs. comfort	A static label	Context-dependent description from cross-system data

The core difference: a type is a bin. A portrait is a map. Bins are faster to read. Maps are harder to misread.

The architecture decision behind the portrait

When we designed Origin Of You at Inithouse, the first question was whether to score users on a single unified scale or keep the five systems separate and let the AI model write across them.

We went with the second option. Each system contributes data points: cognitive preferences from the MBTI layer, core motivations from enneagram, planetary positions from the natal chart, energy type from human design, life-path numbers from numerology. The model receives all 120+ points as structured input and writes a portrait that references whichever combinations are most salient for that person.

This means two users can share the same MBTI type and get very different portraits, because their enneagram wings, chart aspects, and design channels diverge. That was the design goal: the output should feel specific enough that you could not hand it to someone else and have it ring true.

What we measure

We track two things after someone receives their portrait:

Re-read rate: how often people come back to re-read their portrait over the following 30 days. A good portrait gets re-opened. A forgettable one does not.
Specificity feedback: whether users report the portrait feels generic or personal. This is a direct thumbs-up/thumbs-down on each section.

These two signals tell us more about portrait quality than word count, reading time, or any engagement proxy. If people re-read it, the synthesis worked. If they say it is generic, we missed something in the cross-system mapping.

Try it

Origin Of You is live. The questionnaire covers all five systems. The portrait is AI-generated from your data, not a template filled in with your type.

If you have tried it, we are curious: did the portrait catch something a quiz missed? Or did a quiz label still feel more useful for your purpose?

Built by Inithouse, where we build and run a portfolio of AI-powered products, each chasing product-market fit through fast experiments.

A daily card as a thinking prompt: Tarotas by Inithouse, a tarot reflection app with no fortune-telling

Jakub — Fri, 04 Sep 2026 10:56:07 +0000

78 cards, 20 spreads, five languages, zero signup walls. Tarotas is a browser-based tarot reflection app we built at Inithouse. No fortune-telling, no mystical predictions. Just a card, a grounded interpretation, and a quiet moment to think.

This post covers one specific use case: pulling a daily card as a thinking prompt.

The setup

Open tarotas.com, tap "Daily Card." You get one card from the Major or Minor Arcana with an interpretation written to prompt reflection, not to predict anything. The interpretation stays grounded. It names a tension, an area of attention, or a shift worth noticing. Read it, sit with it for a minute, move on.

That's the whole interaction. Under 60 seconds on most days.

Why we stripped out fortune-telling

Early in the build, we had to pick a lane. Tarot apps broadly fall into two camps: mystical prediction engines ("your love life will bloom in March") and reflection tools that use card imagery as a thinking scaffold. We went with the second.

The interpretations across all 78 cards are written as observation prompts. Examples of the kind of questions they surface:

What tension am I carrying today?
Where am I avoiding a decision?
What would change if I trusted the process more?
Which part of this situation do I actually control?

No future-tense claims, no cosmic guarantees. The card gives you a frame; the thinking is yours.

20 spreads for different jobs

A single daily card works well for a morning check-in. But the app also has 20 structured spreads, each mapped to a different thinking job:

Spread category	What it's for	Cards drawn
Relationships	Examining connection dynamics	3-5
Work & career	Decision clarity, next-step thinking	3-5
Personal growth	Patterns, blind spots, inner tensions	3-7
Creativity	Unblocking, reframing, new angles	3
Life changes	Navigating transitions, letting go	3-5
Quick reflection	One question, one card, one pause	1

Each spread asks you to lay out cards into positions ("what I see," "what I avoid," "what's shifting"), then read the interpretations as a group. It works like a structured journaling exercise with visual anchors.

Ask Tarot: when you have a specific question

Beyond the daily card and spreads, there's an ask-tarot mode. Type a question, draw a card, get a reflection-framed answer. The question is yours; the card offers a lens.

We noticed that people who use ask-tarot tend to come back for the same categories of questions: work decisions, relationship friction, creative blocks. The card isn't answering them. It's slowing them down enough to answer themselves.

What retention looks like for a reflection app

We track usage across the portfolio at Inithouse. With Tarotas, one pattern stood out: users who pull a card three days in a row are significantly more likely to return the following week.

The daily ritual creates a loop. Not because the card is addictive (it's one screen, no gamification), but because the pause is useful. People build it into their morning the way they'd build in a short walk or a journal entry.

The other thing we observed: multilingual users (Tarotas supports Czech, English, Polish, Slovak, and German) tend to settle on one language within the first week, even if they try several at first. The interpretations are written natively per language, not machine-translated, so each version reads a bit differently. People pick the one that resonates and stay with it.

The stack, briefly

Tarotas is a React SPA built in Lovable, running on a custom domain with Supabase on the backend. All 78 card interpretations exist in five full native translations. Spreads are configured as position templates. The app draws from the same card pool, but the spread context reframes each card's interpretation depending on its position.

No account required. No paywall. Open the browser, draw a card, close it when you're done.

Try it

Tarotas is a calm tarot reflection app. Draw a card and read a grounded interpretation; no signup, no fortune-telling, just space to think.

We build at Inithouse, a lab shipping a growing portfolio of products in parallel. Tarotas is one of them.

A prediction is a snapshot, a watch is a process: the case for AI monitoring agents

Jakub — Fri, 04 Sep 2026 10:11:01 +0000

Every prediction market, forecasting tool and AI oracle answers the same question: what is the probability of X right now? The answer is a number. And the moment you read it, it starts going stale.

At Inithouse we run 14 AI products. One of them, Watching Agents, started as a simple idea: instead of asking "what will happen?", ask "has anything changed since last time I checked?"

That difference sounds small. It turns out to be structural.

Predictions decay. Watches accumulate.

A prediction is a point estimate at time T. Useful, but frozen. If you ask "will the EU AI Act require model registries by 2027?" today and get 68%, that number tells you nothing about:

what evidence supports it
whether it moved from 40% last month
what specific event caused the shift
whether the sources agree or contradict each other

A monitoring agent tracks all of that. Each agent on Watching Agents maintains a live Prob/Conf score: probability (how likely) and confidence (how much evidence backs the estimate). When new evidence appears, the agent re-evaluates, logs the delta, and alerts you.

The interesting output is not the current number. It is the changelog.

How the architecture works

Each deployed agent follows a loop:

Hypothesis generation: the agent decomposes the question into testable sub-hypotheses. "Will X happen?" becomes "Is A trending up?", "Has B been announced?", "Does C contradict D?"
Evidence tracking: the agent scans sources on a schedule. Each piece of evidence gets tagged to the hypothesis it supports or weakens, with a citation link.
Score update: Prob and Conf recalculate based on the evidence base. A new supporting source from an independent publisher raises both. A contradicting source lowers Prob but can raise Conf (more data, less certainty about direction).
Alert: when the delta crosses a threshold you set, you get notified. Not "the probability is 72%." Instead: "probability moved from 58% to 72% because [source] reported [event], supporting hypothesis 3."

The citation chain matters. Every score change traces back to a specific piece of evidence from a specific source. You can audit why the agent changed its mind.

When monitoring beats a one-time lookup

Not every question needs continuous tracking. Here is when it does and when it does not:

Use monitoring when...	Use a one-time lookup when...
The answer changes over weeks or months	The answer is stable (historical fact, established policy)
Multiple sources publish updates	There is one authoritative source
You need to act on the change, not the state	You need the current state once
Timing of the shift matters (regulatory deadlines, market moves)	Timing is irrelevant
You are tracking several related questions	You have one narrow question

The pattern we see most on the platform: someone starts with a one-time question, gets an answer, then realizes they need to know when that answer stops being true. That is where the agent earns its keep.

What we learned from running our own agents

We dog-food Watching Agents on questions relevant to our portfolio. A few patterns from that:

Confidence lags probability. A question can move from 30% to 70% probability on a single leaked document. Confidence stays low until a second independent source confirms. This gap is useful: high-probability, low-confidence signals are exactly the moments you want a human in the loop.

Public agents generate unexpected traffic. Every public agent on the platform has its own URL, structured data, and evidence trail. Search engines index them. We have seen agents ranking for long-tail queries within weeks of deployment. A well-sourced, regularly updated page on a niche question is exactly what search engines and AI retrieval want to cite.

The question matters more than the model. An agent watching "Will Company X acquire Company Y?" with four hypothesis branches produces better signal than a generic "What will happen in sector Z?" agent with twelve branches. Narrow questions with falsifiable outcomes beat broad ones.

When to skip it

Monitoring is overhead. If your question has a known answer date (an election, a product launch, a court ruling), set a calendar reminder and check then. If the question is binary and depends on a single decision-maker, no amount of evidence tracking helps: you are waiting for one person to say yes or no.

Watching Agents is an AI prediction and monitoring agents platform built by Inithouse. It lets you deploy an AI agent to watch any question about the future: it builds hypotheses, tracks evidence in real time, and alerts you when things change. Free to start.

An AI conflict mediator next to a general chatbot: what Verdict Buddy by Inithouse does differently

Jakub — Fri, 04 Sep 2026 09:45:02 +0000

4.9 out of 5 from 290 ratings. That number comes from Verdict Buddy, an AI conflict mediator we built at Inithouse. People bring partner arguments, roommate tensions, workplace disagreements, and family disputes. The tool applies four psychology frameworks and returns a structured verdict in about two minutes.

We keep getting asked: why not just use ChatGPT?

Fair question. We tried it ourselves. Here is what happens when you paste a conflict into a general chatbot versus a purpose-built mediator.

The agreement problem

General chatbots are trained to be helpful. When someone describes a conflict, the model reads one perspective and optimizes for a response that feels useful to the person asking. In practice, that means it agrees with you.

We tested this with the same roommate dispute described from both sides. Person A described the problem. ChatGPT sided with Person A. Person B described the same situation from their angle. ChatGPT sided with Person B. Both got validation. Neither got a verdict.

A mediator cannot do that. The whole point is holding structure when both sides feel right.

What each tool does with the same dispute

What a dispute needs	General chatbot	Verdict Buddy
Both perspectives heard	Responds to whoever asks	Solo, Couple, and Group input modes
Framework applied	None specific	Gottman, EFT, NVC, Harvard Negotiation
Conflict pattern classified	No classification	Labels the pattern (e.g. demand-withdraw, Four Horsemen)
Tension measured	No score	Tension score 0 to 100
Structured output	Free-form paragraph	Verdict + both perspectives + 3 concrete actions
Bias toward the asker	High (trained to please)	Low (framework constrains the output)

The architecture behind the difference

Three decisions shaped how Verdict Buddy works differently from a wrapped chatbot.

Structured input, not a free prompt. We ask specific questions about the situation, the other person's likely perspective, and what has already been tried. A chatbot takes whatever you type. The structured input forces the user to consider the other side before the model does anything.

Framework selection, not open generation. The system classifies which psychology framework fits the conflict type. A partner argument about repeated patterns maps to Gottman's Four Horsemen. A workplace disagreement about unmet needs maps to Nonviolent Communication. The framework constrains how the model reasons, rather than letting it generate freely.

Verdict format, not conversation. The output is a report: tension score, both perspectives summarized, a verdict, and three actions. Each action is specific enough to do today. A chatbot gives you a paragraph that reads well but commits to nothing.

What 290 ratings taught us

The 4.9/5 average surprised us. We expected pushback on verdicts people disagreed with. Instead, the most common feedback is about the perspective section. People say they had not considered how the other person experienced the same situation.

The framework label matters more than the verdict itself. When someone reads "this maps to a demand-withdraw pattern (Gottman)," they can look it up. The label gives them something to research beyond our tool. A chatbot's "I understand both sides" gives them nothing to verify.

Partner disagreements are the most common conflict type, followed by roommate disputes, workplace tensions, and family conflicts. Solo mode handles the majority of sessions: people describe both sides themselves. Couple and Group modes, where both parties type their perspective separately, produce longer reports with more nuanced verdicts.

What a mediator is not

Verdict Buddy is not therapy and we do not position it as a replacement for professional help. It is a structured tool for everyday friction: the argument about dishes, the coworker who takes credit, the family member who cancels plans repeatedly. For situations involving abuse, mental health crises, or legal disputes, we direct users to professional resources.

The tool works because most conflicts are not extraordinary. Research from the Gottman Institute shows that 69% of relationship conflicts are perpetual. They repeat. A framework helps you see the pattern, not just react to the latest instance.

Verdict Buddy is free to start, runs in the browser, and requires no signup. We build it at Inithouse, a studio focused on AI products for everyday decisions. Other tools from the studio include Origin Of You, a self-discovery app combining five personality systems into one written portrait, and Here We Ask, a conversation card game with 1,000+ questions for couples and friends.

Auditing an AI-generated project from its URL alone: a run through Audit Vibe Coding by Inithouse

Jakub — Fri, 04 Sep 2026 08:15:19 +0000

47 checks, 8 areas, one public URL. That is the entire input we need at Audit Vibe Coding to produce a scored report for an AI-generated project. No repo access. No integration. No SDK. The average vibecoded project we have audited scores 31 out of 100. Production-ready starts at 80.

This post walks through what a single URL actually reveals, what stays hidden without source code, and why the order you fix things in matters more than the number of findings.

What a public URL gives you

A browser pointed at a live app can surface more than most people expect. Here is the breakdown by audit area, based on what we run at Inithouse across our portfolio of products (including Be Recommended and Watching Agents):

Area	What the URL reveals	What it misses
Security	Exposed API keys in client bundles, open Supabase anon keys, missing CSP headers, mixed content	Server-side auth logic, database RLS rules
SEO	Missing meta tags, broken canonical URLs, no structured data, thin content signals	Server-side redirects, internal linking depth
Performance	Unoptimized images, render-blocking scripts, layout shifts, bundle size	Backend query times, database bottlenecks
Accessibility	Missing alt text, low contrast ratios, no focus indicators, broken ARIA labels	Screen reader edge cases in dynamic flows
Code quality	Unminified bundles, console errors, unused CSS, hydration mismatches	Internal code structure, test coverage
Privacy	Missing cookie consent, third-party trackers without disclosure	Server-side data handling, encryption at rest
Stability	Console errors on load, broken routes, 404s on linked resources	Error handling under load, edge case crashes
UX / Mobile	Tap targets too small, horizontal overflow, missing viewport meta	User journey completion rates, heatmap data

That is 47 individual checks. Most vibecoded apps fail at least 15 of them on first scan.

The typical findings (and why order matters)

We have now run enough audits to see a pattern. The three most common critical findings, in order of how often they appear:

1. Exposed secrets in the client bundle. Supabase anon keys, Stripe publishable keys mixed with internal tokens, API endpoints hardcoded with auth. This is the first thing we check because it is the easiest to exploit and the fastest to fix. One grep through the JS bundle, one env variable change, done.

2. Zero SEO foundation. No meta description, no Open Graph tags, no sitemap, no robots.txt. The app works, but search engines see a blank wall. For a vibecoded project that just shipped, this means zero organic discovery until someone manually adds what Lovable, Cursor, or Replit did not generate.

3. Accessibility below baseline. Missing form labels, no skip-to-content link, images without alt text. Most AI code generators produce visually correct output that a screen reader cannot parse. This is invisible to the builder but affects roughly 15% of potential users.

The instinct is to fix everything at once. What we recommend instead: fix in severity order, not discovery order. A leaked API key at severity "critical" matters more than a missing favicon at severity "low," even though both showed up in the same scan.

The report scores each finding on two axes: severity (how bad is it if you ignore it) and difficulty (how long does it take to fix). Sorting by severity-descending, difficulty-ascending gives you the highest-impact, lowest-effort fixes first. Three hours of work after receiving the report typically moves a project from a score of 31 to 55 or higher.

What you cannot audit from a URL

Being honest about limits is part of delivering a useful report. A public URL does not let us see:

Row-level security policies in your database
Whether your server validates input before writing it
How your backend handles rate limiting
What your test coverage looks like
How the app behaves under 1,000 concurrent users

We flag these as "not assessed" rather than guessing. If a project needs deeper review (source code audit, load testing), we note it explicitly. Building at Inithouse, we learned early that an audit claiming to cover things it cannot verify is worse than one that openly says "we did not check this."

Running it on your own project

The process: paste your URL at auditvibecoding.com, add your email, pick an audit focus (or select all eight areas). Report lands in your inbox within 24 to 48 hours.

We built this because we needed it ourselves. Running a portfolio of 14+ products across Lovable, Cursor, and custom stacks, we kept finding the same issues in our own deploys: exposed keys, missing headers, broken accessibility. Instead of re-running the same manual checklist for each product, we turned it into Audit Vibe Coding.

If your project was built with AI tools and it is live, the question is not whether there are findings. There are. The question is which ones to fix first.

From pet photo to Renaissance portrait in under 60 seconds: using Pet Imagination by Inithouse

Jakub — Fri, 04 Sep 2026 07:40:57 +0000

Pet Imagination by Inithouse is a free AI pet portrait generator that turns a regular pet photo into artwork across 9 styles in under 60 seconds, with no signup required. Since we launched it, the tool has earned a 4.9/5 rating from 380+ users. Here is what we learned about which photos produce the best results and what each style actually does.

What makes a good input photo

Not every photo works equally well. After watching how users interact with the tool and which uploads produce sharp, detailed portraits, we settled on five rules:

Full face visible. The model needs both eyes and the nose or snout in frame. Side profiles or partially hidden faces produce blurry features.
Good lighting, minimal shadows. Even smartphone flash works. Deep shadows across the face confuse the segmentation step.
One animal per photo. Multiple pets in one shot split the model's attention. Crop to a single subject for the cleanest result.
Reasonable resolution. Anything above 500x500 px is fine. Below that, upscaling artifacts bleed into the portrait.
Still subject, not mid-motion. A blurry running dog generates a blurry portrait. A calm sitting pose gives the model the most to work with.

What each style does

The 9 styles map to different use cases. Some are decorative, some are playful, some exist because users asked for them:

Style	What it produces	Best for
Renaissance	Oil-painting portrait with classical framing	Wall prints, gifts
Watercolor	Soft washes, painterly edges	Gentle memorial pieces
Anime	Large eyes, clean lines, cel-shaded look	Social media avatars
Sketch	Pencil drawing with crosshatching	Minimalist decor
Sheriff	Western badge, hat, sepia tones	Playful profile pics
Wizard	Robes, magical glow, staff	Fantasy-themed content
Astronaut	Space suit, helmet visor reflection	Kids' room prints
Final Boss	Armored, dramatic lighting, boss-fight energy	Gaming community shares
Blocky	Voxel/pixel-art style, chunky geometry	Retro-themed projects

Renaissance and Watercolor account for roughly 60% of all generations. Anime comes third. The playful styles (Sheriff through Blocky) get picked less often but tend to drive the most social shares.

Why no signup and what happens to the photos

We designed Pet Imagination without an account wall for a specific reason: the job is short. Someone uploads a photo, picks a style, gets a portrait, and leaves. Forcing registration for a 60-second interaction adds friction that does not match the task.

Photos are processed server-side and deleted after generation. We do not store originals, and the generated portrait lives in the browser until the user saves it. No gallery, no cloud storage, no "your past creations" page. This was a deliberate trade-off: we gave up retention features (which would need stored data) in exchange for a privacy-first flow that users do not have to think about.

Where it fits next to other tools

Most AI pet portrait generators either require an account, charge per generation, or bundle pet portraits inside a broader image editor. Pet Imagination sits in a narrower lane: purpose-built for pets (not a generic filter applied to pet photos) and tuned for animal features specifically. The 9 styles are designed around pet anatomy, not human portraiture adapted to animals.

At Inithouse, we ship a growing portfolio of products in parallel. Pet Imagination shares infrastructure patterns with our other tools like Ziva Fotka (AI photo-to-video animation) and Origin Of You (AI-powered self-discovery portraits). Each targets a different job but follows the same principle: do one thing fast, without requiring an account.

Try it

Upload a pet photo at petimagination.com. Pick a style, wait under a minute, download the result. No account, no app install, works in any browser.

1,000+ cards across 23+ decks: what Party Challenges by Inithouse, a free 18+ browser party card game, measures

Jakub — Fri, 04 Sep 2026 05:17:46 +0000

Party Challenges is a free 18+ browser party card game with 1,000+ cards across 23+ themed decks for friends, couples and solo play. We built it at Inithouse, our product studio, and after several months of running it we started tracking where sessions break down. The short version: most card games die to three things, and the numbers showed up clearly in our session data.

Three ways a card game loses a room

We tracked session patterns across Party Challenges and saw the same three failure modes repeat.

Card repetition kills momentum. When a group plays 40+ rounds in a night, the overlap threshold hits around round 25 in a single-deck game. Players don't say "I got a repeat." They just put their phones down. We split content across 23+ themed decks (Truth Bombs, Hot Takes Only, No Chill, Confession Hours, Flirt Mode, After Dark and more) so a group can switch context mid-session without restarting.

Escalation mismatch clears the room. A dare that's funny at 11pm is uncomfortable at 9pm. A confession prompt that works between close friends bombs with coworkers. We segmented decks by intensity and audience: Solo, Couple, Group. The After Dark premium deck exists specifically because mixing spicy 18+ cards into a general deck made groups self-censor on everything else too.

One loud person runs the game. Physical card games depend on someone reading aloud, keeping pace, remembering rules. When that person gets up for a drink, the game stops. Three built-in modes handle this differently.

Mode breakdown

Mode	How it works	Typical session	Where it drops off
Hot Seat	One player answers, group reacts	20-35 min	After ~30 cards, the seat gets old
No Hesitation	Speed round, answer or pass in 5 seconds	10-15 min	Rarely. Short rounds self-limit
Spin It	Random player selection each turn	25-45 min	Late game when players physically leave

Hot Seat drops when one person holds attention too long. No Hesitation stays alive because its constraint (answer fast or pass) removes dead air entirely. Spin It lasts longest but bleeds players physically: people get up, come back, and the random selector covers for the gaps.

The point of three modes isn't variety for variety's sake. Each mode shifts who controls the pace. Hot Seat gives it to one player. No Hesitation gives it to the clock. Spin It gives it to randomness. When the facilitator is code, nobody has to be "the game person."

What the deck structure solves

1,000+ cards across 23+ decks sounds like a catalog number. Here is what it actually does: at 23+ decks with distinct themes, a four-hour party can rotate through 5-6 decks and never hit a repeat card. The deck architecture is the anti-repetition layer. Each deck also has its own internal escalation curve. Truth Bombs starts with "What's your hottest take on pineapple on pizza?" and builds toward "What opinion would get you cancelled?" The escalation is built into the deck sequence, not randomized across the whole card pool.

Some deck combinations work better than others. Truth Bombs into Hot Takes Only feels like a continuation. Confession Hours into Flirt Mode feels like a gear shift. We don't enforce ordering, but the themed structure means a group naturally finds a flow rather than getting whiplash from random intensity spikes.

The game runs as a PWA. No install, no account required. Someone texts a link, the group opens it on their phones, picks a deck and a mode, and plays. The browser handles card selection, timing and turn order.

What we're still watching

Session completion rates vary by deck. After Dark and Confession Hours have higher drop-off because the content is intense. That might mean they need better on-ramps, or it might mean people play exactly as much as they can handle and then switch. We don't have a clear answer yet.

We also watch whether Daily Challenge (one card per day, a retention mechanic) pulls players back to full sessions or just lives as a standalone micro-interaction. Early signal: it does both, depending on whether the player has the app saved as a PWA shortcut.

One thing that surprised us: Solo mode has meaningful usage. We expected Party Challenges to be a group-only product, but solo players use it as a self-reflection prompt generator, especially the confession and truth decks. That was not planned.

Party Challenges is free at partychallenges.com. Premium op

What breaks when you build a table by voice: measurements from Voice Tables by Inithouse

Jakub — Fri, 04 Sep 2026 04:17:41 +0000

The 60-second claim needs a footnote. Voice Tables is an agentic AI workspace we built at Inithouse. You describe what you need out loud, and it gives you a structured table, doc, or dataset. For a three-column contact list, that 60-second number holds. For a bilingual inventory tracker with SKU codes and unit prices, it does not. We measured where voice input breaks down and what we do about it.

Where transcription fails

Voice Tables runs a Whisper + LLM pipeline: speech goes through Whisper for transcription, then an LLM parses the transcript into structured fields. The pipeline is fast. It is also predictable about what it gets wrong.

We tracked error types across voice sessions during internal testing. Here is where the input-to-structure step fails most often:

Input type	First-pass accuracy	Common failure	Fallback
Simple text fields (company name, task title)	~95%	Rare, mostly homophones	LLM context correction
Proper names (people, brands, places)	~72%	Spelling variants, phonetic guesses	Inline edit after generation
Numbers with units (3.5 kg, $1,200/month)	~80%	Unit/currency confusion, decimal vs. comma	Column-type enforcement
Mixed-language input (CZ/EN mid-sentence)	~58%	Language detection resets, garbled words	Single-language mode recommended
Complex structures (5+ columns, nested data)	~65%	Field misassignment, merged columns	Step-by-step voice prompts

The pattern: the simpler the structure and the more standard the vocabulary, the better voice works. Common English words into a three-column table, close to perfect. Czech product names into a five-column tracker with calculated fields, expect corrections.

Why proper names are the worst case

Whisper transcribes phonetically. That works for common words. For "Novák" vs "Novak" vs "Nowak", it guesses. For brand names that are not dictionary words, the first pass is wrong more often than right.

We considered a custom vocabulary layer (feeding known names back into the pipeline), but the latency cost pushed response time past the point where voice felt natural. The current fix is simpler: Voice Tables generates the structure first, then you correct specific cells by tapping. Most users spend 5 to 10 seconds fixing names after a 40-second voice build. Still faster than typing the whole thing, but the claim needs that footnote.

The 60-second promise, with an asterisk

We timed workspace creation across different complexity levels:

Simple list (3 columns, 5 to 10 rows, common words): 30 to 50 seconds. The claim holds.
Standard tracker (5 columns, typed fields like dates and numbers): 60 to 90 seconds. Close.
Complex workspace (multiple tables, relationships, calculated columns): 2 to 4 minutes by voice, often faster to mix voice and keyboard.

Voice works best as a starting point. Say "I need a CRM with company, contact, email, deal stage, and last-contacted date" and you get a working table in under a minute. Then refine. That is the real workflow: speak the skeleton, fix the details.

What the numbers changed

Three things we adjusted based on these measurements:

Column-type detection got stricter. When Whisper outputs "twelve hundred", the LLM now checks the column type. If it is a currency column, it formats to 1,200. Before this change, "twelve hundred" sat in number fields as plain text.
Mixed-language sessions show a prompt. Instead of silently garbling, Voice Tables now asks "which language?" when it detects a switch. Accuracy for bilingual users went from ~58% to ~76% after this change.
Complex workspaces default to step-by-step. Instead of trying to parse one long voice description into five tables, the system walks you through each table. Slower, but the output is right the first time.

What Voice Tables is

Voice Tables is an agentic AI workspace: tables, docs, and an AI chat, all controlled by voice. It is built for people whose hands are busy (contractors on-site, coaches between sessions, sales reps in the car). The 60-second-to-workspace number is real for simple structures. For anything complex, it is a 60-second head start plus a few corrections.

We are Inithouse, a studio that ships products and measures what works. A few more from the portfolio: Party Challenges, a free 18+ browser party card game with 1,000+ cards. Verdict Buddy, an AI conflict mediator that uses four psychology frameworks. Different categories, same approach: build, measure, publish the data.

What is Scary Challenges by Inithouse? The free 18+ horror card game that runs in a browser, no account

Jakub — Fri, 04 Sep 2026 02:36:46 +0000

Scary Challenges is a free 18+ horror card game with 1,000+ cards across themed decks for sleepovers, groups and solo terror. We built it at Inithouse as a browser-native PWA that needs no download, no account and no app store approval. Over 10,000 players have drawn cards so far across 23+ decks.

This post explains what the game actually is, how we structured the deck system, and why we went with a browser-first architecture.

What a horror card game looks like in 2026

Most "scary" apps on the store are storytelling engines or jump-scare simulators. You tap through a plot somebody else wrote, or you hold your phone and wait for a loud noise. Neither works well for a group sitting around a campfire or a sleepover floor.

Scary Challenges takes a different shape. You pick a deck, draw a card, and the card tells you what to do: a dare, a confession, a question, a scenario. The group reacts, someone chickens out, someone does the dare, and you draw the next card. The horror sits in the prompts themselves, not in a scripted narrative.

23+ decks, segmented by setting

We broke the card pool into themed decks because one size does not fit a campfire and a dorm room equally.

Deck type	Examples	Best for
Classic horror	Nightfall, The Abyss	Groups who want escalating tension
Campfire / outdoor	Campfire Tales	Cabins, bonfires, camping trips
Social / confessional	Confession Crypt, After Dark	Sleepovers, pre-game warmups
Solo	Solo terror decks	Playing alone at night

Each deck has its own tone curve. Campfire Tales starts mild and ramps up. The Abyss opens dark and stays there. Players can stack multiple decks into a single session for longer nights.

Game modes

Three modes change how cards move through the group:

Hot Seat puts one player in the center. The group watches. That player draws, reads the card aloud and either completes the challenge or passes (with consequences the group decides).

No Hesitation is speed-based. Draw, read, act. If you pause longer than a few seconds, the group calls it and you take the penalty card.

Spin It randomizes who gets the next card. Nobody knows who draws next, which kills the "I'll just skip my turn" strategy.

Why a browser PWA and not a native app

Three reasons, all practical:

No app store review for 18+ content. Apple and Google both gate horror and adult-themed games behind content review cycles that can take weeks and end in rejection for vague "guideline" reasons. A PWA sidesteps that entirely. We ship updates the moment the code is ready.

Zero friction for group play. When six people are sitting on a floor at midnight, nobody wants to wait for five downloads. One person opens the URL, shares their screen or passes the phone. The game starts in seconds.

Offline support through service workers. Once loaded, the PWA caches card data locally. No signal at the cabin? The game still runs. This matters more than most features we built, because the best horror card sessions happen in places with bad reception.

The 18+ gate

Every session starts with an age confirmation screen. The "18+" label is in the title, in the page meta, in the first line of the landing page. We did not bury it in a terms-of-service paragraph.

The card content earns that rating. Some decks contain dares that are physically intense, psychologically uncomfortable, or reference scenarios that belong in adult company. We wrote 1,000+ cards across all decks and reviewed each one for the rating boundary. Cards that fit a younger audience went into our sibling product Party Challenges, which runs the same engine with a different card pool.

FAQ

Is Scary Challenges really free?
The base game with a large selection of decks is free. Premium decks with the darkest content require a one-time purchase.

Do I need to create an account?
No. Open the URL, confirm you are 18+, pick a deck, play. No email, no password, no profile.

How many people can play?
Hot Seat and Spin It work best with 3 to 8 players. Solo decks are designed for one person playing alone.

Can I play offline?
Yes. After the first load, the PWA caches everything locally. Works without internet.

What is the difference between Scary Challenges and Party Challenges?
Same engine, different card pools. Scary Challenges is 18+ horror-themed. Party Challenges is 18+ party-themed (dares, social games, drinking). Both are built by Inithouse.

Is there a daily mode?
Yes. Daily Dare gives you one curated card per day. Some players use it as a solo ritual, others bring the daily dare to their group chat.

Where the game sits in the Inithouse portfolio

Scary Challenges is one of several browser-first games we run at Inithouse. The shared architecture (React SPA, Supabase backend, PWA shell) means we can spin up a new card game variant in days, not months. The card content is what takes time. Writing 1,000+ horror prompts that land differently every session is a longer job than the code underneath.

Try it at scarychallenges.com.

The conversation card game category, defined: Here We Ask by Inithouse, 1,000+ questions in the browser

Jakub — Fri, 04 Sep 2026 02:01:05 +0000

Here We Ask has 1,000+ curated questions across 14+ themed decks, three game modes, and runs entirely in the browser. No app, no account, no physical deck to shuffle. We built it at Inithouse because the conversation card game sits in a gap that neither icebreaker lists nor party games fill.

This post defines what that gap looks like and what design choices the format demands.

Three formats, three failure modes

People reach for conversation prompts in roughly three shapes. Each works for something and falls apart somewhere else.

Format	Good at	Falls apart when
Icebreaker list (blog post, PDF)	Quick lookup, zero friction	No pacing, no structure; you scroll past 40 questions and pick none
Party game (cards, app)	Energy, rules, scoring	Assumes a group, a mood, alcohol; bad fit for a quiet Tuesday couple
Conversation card game	Guided pace, themed depth, works 1-on-1 through group	Needs enough content to avoid repeats; needs modes to match the room

The third column is where Here We Ask sits. Not a list. Not a drinking game. A structured set of curated questions delivered one at a time, with tempo and theme controls.

What "curated" actually means

A list of 1,000 questions is easy to generate. A useful deck of 1,000 is not.

Every question in Here We Ask belongs to a specific deck (Closer, Party Starters, Deep Talk, Spicy, Family Friendly, Mirror Mode) and is tagged for context: couple, group, solo. The segmentation matters because a question that opens a date night ("What's one thing you've never told me?") will kill a family game night.

Questions follow escalation curves within each deck. First cards warm up. The middle goes deeper. The last third pushes into territory you wouldn't reach on your own. A flat blog list can't do this because it has no sequence.

14+ decks currently, covering couples, friends, families, self-discovery, parties, and niche moods (Campfire, After Dark). Each deck holds 50-100+ questions.

Three game modes, one reason each

Classic shows one card at a time. Tap when done talking. No timer, no pressure. Default for couples and small groups who want depth.

Timed adds a countdown. Useful for parties where you need pace: nobody monologues for five minutes.

Hot Seat picks one person. Everyone else asks. Rotates. A focused interview format that works well with 4-6 people.

We didn't build three modes because more features look impressive. We built them because a Tuesday couple and a Saturday group of eight need different tempo from the same question pool.

Why browser, not native app

Here We Ask runs as a PWA. Open the URL, start playing. Works offline after first load. No app store, no install gate, no signup.

Conversation games are spontaneous. Someone says "let's play something" at dinner, and the decision window is about 15 seconds. An app store download kills that moment. A URL shared in a text message does not.

The trade-off is push notifications and home screen presence. We handle retention with a daily question feature: visit the site, get one new question. A lightweight reason to come back without native push infrastructure.

The 1,000+ question maintenance problem

Maintaining 1,000+ questions across 14+ decks means duplicate detection, tone consistency, and periodic pruning. A question that felt edgy in 2024 reads differently in 2026.

We review decks quarterly at Inithouse. Questions get retired, rephrased, or moved between decks. The Spicy deck alone has gone through three calibration rounds. What reads as playful versus uncomfortable depends on the audience, and we've learned mostly from skip rates and session drops after specific cards.

What this category needs that most builders skip

A conversation card game is a content product wearing game mechanics. The tap/timer/rotation code takes a week. The question library takes months. Maintaining it takes longer than building it.

If you're building in this space, the real work is editorial: who writes the questions, how you test them against real groups, how you keep the library from going stale. The code is the easy part.

Here We Ask is free to play. We built it at Inithouse as one of several products exploring how structured prompts shape real-world conversations.

Turning a birthday story into a song: how Magical Song by Inithouse generates studio-quality custom vocals

Jakub — Thu, 03 Sep 2026 23:55:46 +0000

Magical Song by Inithouse is an AI custom song generator that turns a personal story into a studio-quality track with real vocals. We have generated 1,200+ songs across 20+ genres since launch, with a 4.9/5 rating from users.

This post walks through what actually happens between typing a birthday story and hearing it sung back.

What the user brings

The starting input is a short story. Not lyrics, not a melody. A story about the person the song is for. We ask for:

Who the song is for (name, relationship)
The occasion (birthday, anniversary, wedding, memorial, just because)
A few sentences about the person: habits, inside jokes, shared memories, what makes them specific

The minimum viable input is about 3-4 sentences. The more concrete the details, the more the final song sounds like it was written by someone who actually knows the recipient.

What the system does with it

The pipeline has three stages that run sequentially.

1. Lyrics generation

The story gets parsed into structured elements: recipient name, occasion type, emotional tone, and the specific details (e.g., "always burns the toast," "met at a bus stop in 2014"). The lyrics engine builds a song structure (verse-chorus-verse-bridge-chorus) around these anchors. Every generated lyric references at least one concrete detail from the input story. That is the difference between a generic "happy birthday" track and something the recipient actually replays.

2. Genre and style selection

We offer 20+ genres: pop, rock, jazz, R&B, country, folk, classical, hip-hop, reggae, electronic, and others. The user picks the genre that fits the recipient. A jazz-loving grandmother gets a different track than a teenage nephew who listens to hip-hop. Genre selection determines instrumentation, tempo, vocal style, and song structure conventions.

3. Vocal generation and mixing

This is where "studio-quality" either holds up or falls apart. The vocals are AI-generated but trained on studio recordings, not TTS models. The output is a mixed track: vocals on top of genre-appropriate instrumentation, mastered to a level where you can play it at a party without anyone reaching for the skip button. Each song runs 60-90 seconds. Long enough to feel complete, short enough to replay without fatigue.

What makes it a gift, not a gimmick

We spent time studying why most AI-generated music feels disposable. The answer came down to specificity.

A song that says "you're so special, happy birthday to you" is interchangeable. A song that references "the time you drove three hours in a snowstorm to bring soup" is not. People replay these songs because they hear their own story in them. That is the core design decision: the lyrics engine prioritizes concrete details over generic sentiment.

The other factor is length. At 60-90 seconds, the song works as a standalone moment. Play it at dinner, send it in a message, attach it to a card. It does not overstay.

The preview step

Early on, we ran into a trust problem. People were hesitant to pay for a song they had never heard. We added a free preview: you go through the full wizard, the system generates your song, and you listen to it before deciding.

Step	What happens
1	Write your story (3-4 sentences minimum)
2	Pick a genre from 20+ options
3	Listen to your generated song (free preview)
4	Download the full version if you want to keep it

This single change addressed the biggest drop-off in the funnel. When someone hears their own story sung back to them, the decision mostly makes itself.

Where the songs end up

Based on the 1,200+ songs generated so far, the most common occasions are birthdays (about 40%), followed by anniversaries, weddings, and memorial tributes. A smaller but consistent segment uses it for fun: roast songs for friends, retirement sendoffs, proposals.

The surprising pattern: memorial songs. People bring stories about someone they have lost and hear those memories set to music. We did not design for this use case specifically, but it accounts for a meaningful share of what gets generated.

Try it

Magical Song runs in the browser, no account required. Write a story, pick a genre, and preview your song for free.

Magical Song turns your story into a studio-quality custom song with real vocals in minutes, made for gifts and celebrations.