Seven systems in production.
Seven systems in production, one team behind all of them. A paid prospecting platform running on subscription tiers, a measurement pipeline that delivers 1,080+ AI calls per audit, four autonomous bots on a 7-day cadence, a recruiting engine, an on-demand research studio, an idea-to-spec tool, and a sales-pitch generator that turns any prospect URL into a full opportunity brief. Every system below was designed, built and shipped by the same person who runs the discovery call.
From raw company names to booked sales meetings, tracked per client and per service.
The problem
In small and mid-sized B2B service companies, the CEO is both the buyer and the seller. There is no repeatable way to find prospects: a conference here, a LinkedIn scroll there, a referral if you are lucky.
We had built prospect lists for client CEOs before. Every one of them stayed on paper. Not because the list was wrong, but because nobody knew who to contact, why now, or what to say.
What we built
A multi-tenant pipeline platform where the unit of architecture is a service line, not a company. Each service line carries its own ideal customer profile, its own trigger signals, its own message library and its own pipeline, so one business can run recruitment, AI visibility and engineering services side by side without them bleeding into each other.
Claude researches every company and produces a full opportunity card: why-now signals with sources, ranked contacts, and a written take on the angle. The operator triages one opportunity at a time, keeps or discards, then goes deep on what survives.
How it works
Approvals are hybrid: automatic where the rules are tight, human where they are not. The system compresses hours of manual research into a triage the operator can do over coffee.
Built in six phases from empty repository to first client account live. Every layer of the stack is owned by the client, on their infrastructure.
Measuring whether AI assistants recommend you: 360 data points per audit.
The problem
A brand can see its Google ranking. It cannot see whether ChatGPT recommends it when a customer asks for a recommendation, which is increasingly where the question gets asked first. With no measurement, there was nothing to improve and nothing to argue with.
What we built
An automated audit pipeline. For each brand it researches the business, generates 30 queries across 5 intent categories tailored to that business model, then runs every query three times across four engines: ChatGPT, Gemini, Claude and Perplexity. That is 360 calls per audit, enough to separate a real pattern from a lucky answer.
A three-layer analyzer scores brand presence, competitor share and sentiment. Each run ends in a branded Excel report that syncs itself into the client's Drive folder, so the deliverable arrives without anyone assembling it.
What it found
The first production audit completed at 360 of 360 calls and scored the brand 67 out of 100. A competitive audit in home retail placed that client 8th out of 20 companies measured.
The same finding repeated in every audit since: brands perform well when the customer already knows their name, and disappear on the generic category questions where new customers actually start. That gap is the entire opportunity, and it is why the one-time audit became a monthly tracker.
Two research jobs that needed a person every week, now running themselves.
The problem
Both clients wanted the same two things: a weekly industry newsletter that actually goes out, and a steady flow of qualified prospects.
Both required a person to sit down and do research every week. Both kept slipping, because that person always had something more urgent in front of them.
What we built
Scheduled bots running on GitHub Actions. The newsletter bot researches the week's developments with Claude and web search, drafts the issue in the client's own voice, and sends through Resend, checking every item against a send history so nothing repeats.
The lead discovery bots scan for companies matching each service line's profile, score them in a two-stage pipeline (a cheap Haiku pass to filter, a Sonnet pass for the judgment call) and push the survivors into Monday.com, where the sales owner picks them up in the morning.
How it feels
There is no dashboard to check. No prompt to run. The work arrives.
Each bot went from brief to first automated send in under a week. Once shipped, they operate unattended: Monday morning inbox, Monday morning pipeline, no operator required.
A recruiting engine that walks a candidate from client brief to onboarding.
The problem
Recruiting agencies live inside a mess of spreadsheets, email threads and half-parsed CVs. The moment a role opens, the recruiter is doing the same seven jobs again: reading the JD, matching against the database, writing outreach, syncing calendars, chasing replies.
Every one of those seven jobs is repetitive, language-heavy, and almost impossible to hand off to a junior without losing quality.
What we built
An end-to-end recruiting platform where each of the seven jobs is a dedicated AI module. Candidates flow from a client's role brief through automatic matching, personalized outreach, meeting sync and onboarding, all inside one system.
Recruiters keep the judgment calls. The system handles everything around them, and every action is logged so the agency owner can see exactly what the pipeline looks like across every seat.
Who it's for
Recruiting agencies and in-house talent teams that run more than one role at a time and have already outgrown their spreadsheet.
The system is designed for the operator model that most agencies actually run: one owner, a handful of recruiters, dozens of live roles across many clients.
Candidate analyzer
Reads a CV, extracts skills, experience and fit signals into structured data the recruiter can search.
Gmail sync
Ingests recruiter email threads, pulls out replies, updates candidate status without a manual log.
Client enrichment
Auto-populates client company profiles from public data so recruiters walk in with context.
Job brief ingestion
Turns an unstructured JD into a searchable role definition ready to match against the pool.
Database matching
Ranks the active candidate pool against a new role by fit score with an evidence trail.
Sourcing strategy
Generates a targeted outreach plan when the pool comes up short: where to search, who to message.
Meeting recognition
Identifies who was in each interview and links the notes back to the right candidate record.
User research on demand: real personas, real interviews, real report.
The problem
Every product team needs the same three things before shipping something new: know the market, know the persona, hear how the persona actually talks about the problem. All three cost weeks of scheduling, recruiting and synthesis. Most teams skip them and ship blind.
What we built
Paste a product URL and a research question. The system researches the market, builds 3 to 5 full personas (visual, personal, psychological, demographic), interviews each one in a chat conversation, and returns a findings report you can bring straight into a product review.
It runs inside Vercel's 300-second serverless ceiling, so the whole loop is tuned to complete under that hard limit. It's the only app in the studio that is public without required auth.
Who it's for
Product managers, founders and product marketers who need a directional read on a new idea in an afternoon, not a quarter.
Not a replacement for real interviews. A replacement for the six weeks of nothing you get before them.
Market read
Takes a product URL and researches the surrounding market before generating anyone to interview.
Persona generation
Builds three to five personas per run, each with a visual, personal, psychological and demographic profile.
Live chat interviews
Each persona sits for an actual chat interview against the research question, not a scripted response.
Findings report
Synthesizes every interview into a single report you can bring straight into a product review.
Under the ceiling
The whole loop is calibrated to complete under the serverless execution ceiling, no infrastructure gymnastics.
No login wall
The one system in the studio that runs fully public. Try it, see the shape, then decide.
The system that turns a hackathon idea into a signed-off product spec.
The problem
Hackathons generate ten interesting ideas and ship zero of them. Not because the ideas are bad, but because nobody translates "cool prototype" into "we've decided to build this, here's the spec, here's the cost, go."
The gap between the room where the idea happens and the meeting where it gets funded is where good products die.
What we built
An internal tool that walks a product team from raw hackathon idea through market research, persona interviews, product decision, and finally into a written spec ready for build.
The spec file itself is the source of truth for the product, not the code. Code is a translation of the spec, and the spec updates first when the direction changes.
The cost engine
A dedicated token-accounting layer tracks consumption per model across every round, so the operator sees exactly what each iteration cost and can compare cheap models against expensive ones on the same idea.
The result: product decisions get made with the compute bill visible from step one, not discovered at the end.
Spec as source of truth
The spec file is the product, not the code. Direction changes update the spec first, code follows.
Two planning phases
Research phase surfaces evidence. Decision phase resolves it into a spec ready for build.
Token accounting per model
Every round tracks consumption per model, so cheap and expensive routes get compared on the same idea.
Cost visible up front
The compute bill for each iteration is on screen before commit, not discovered on the invoice later.
Single-operator flow
One person can move an idea from hackathon whiteboard to signed spec without a meeting.
Multi-model routing
Different phases route to different models by cost and reasoning need, all controlled by the spec.
Paste a prospect URL, get back a full digital pitch.
The problem
Agency sales teams burn hours before every discovery call reading the prospect's site, guessing at opportunities, sketching mockups, and translating everything into a story the client will actually understand.
Half the time the deal moves. Half the time it dies before the next meeting.
What we built
A pitch engine for a sales team. The operator pastes a prospect's URL and gets back a full opportunity pitch: an AI-visibility read of the site, an opportunity map, three solution directions, screen concepts, and a suggested engagement model, all tied to the agency's own service catalogue.
Every mockup is generated as HTML, not as an image. No image-generator dependency, no waiting on rendering, no broken fidelity.
How it reads the site
The engine reads the homepage plus up to two internal pages, enough to understand positioning without overreaching or hallucinating.
Every pitch ends with three solution directions mapped one-to-one against the team's own service catalogue, so sales walks in with something to sell, not something to explain.
URL in, pitch out
The whole workflow starts from a single prospect URL. No brief, no form, no manual research pass.
Bounded site read
Reads the homepage plus up to two internal pages, enough context to be sharp, not enough to hallucinate.
AI-visibility read
Diagnoses how the prospect currently shows up (or doesn't) in AI-generated answers.
Three solution directions
Every pitch ends with three concrete solution directions mapped against the agency's own service catalogue.
HTML mockups, not images
Screen concepts render as real HTML, so nothing depends on an image generator and nothing arrives blurry.
Engagement model included
Every pitch ends with a suggested engagement model so sales isn't guessing at scope or shape.
Want to see what this looks like for your stack?
Every engagement starts with measurement, not a build quote. Thirty minutes, a look at where your work is actually going, and a written recommendation you can take anywhere.