DEV Community: Admin Supafast

AskAiRank Review: An Honest, Founder-Written Look at My Own AEO Tracker

Admin Supafast — Mon, 17 Aug 2026 15:37:10 +0000

I built AskAiRank, so this isn't a neutral third-party review. It's the review I wish someone had written before I sank a few weekends into building this thing: what it actually does well, where it falls short, and who should probably wait before signing up.

Why I built it

I run a handful of small SaaS products (a translator app, an AI text tool, a couple of others), and I kept noticing something in the traffic logs: people showing up on a pricing page with zero referrer, zero search query, just a cold visit that converted anyway. Eventually I connected the dots. They'd asked ChatGPT or Perplexity something like "best AI translator for Mac" and got a name dropped straight into the answer.

That's a problem you can't debug the normal way. Google Search Console tells you your ranking for a keyword. Nothing tells you whether Claude mentioned you yesterday, whether it mentioned a competitor instead, or which page it pulled that recommendation from. So I built the tool I wanted for my own products first, then opened it up.

What it actually does

The mechanics are simple on purpose. You set up a list of buyer-intent prompts, things a real person would type when they're shopping for something in your category, not generic keywords. Those prompts get run against the models on a schedule instead of once, because a single check tells you almost nothing. Ask the same question twice and you can get a different answer, a different order, different sources cited. You need to sample over time to see a real pattern, not a coin flip.

Every response gets parsed for brand mentions, position in the list, and any source links the model cites. That rolls up into a visibility score you can compare against competitors you add manually.

On the free plan you get one brand, 10 prompts, and coverage across ChatGPT and DeepSeek. The paid tiers add more prompts, more brands, and the rest of the model lineup, Claude, Perplexity, Gemini, Grok, Llama, Mistral, all the way up.

What's genuinely good

The prompt-and-schedule approach was the right call. In my own testing across our products, I noticed swings from one day to the next that would have looked like noise if I'd only checked once. Watching it over two or three weeks is what actually tells you something.

It's also cheap by category standards. Most of the AEO tools I looked at before building this one start around $100/month and climb fast. I priced this the way I'd want to pay for a tool as a solo founder: a real free tier, then $19 and $39/month steps before you hit anything resembling an "enterprise" price.

Where it falls short, honestly

Mention detection in free-form text is genuinely hard, and I'm not going to pretend it's solved. Models write prose, not structured data. They use aliases, partial product names, "you might also check out X" asides buried mid-paragraph, citations that live in a footnote instead of the sentence itself. I'm still iterating on the parsing logic, and I expect I'll be iterating on it for a while. If your brand name is generic or overlaps with a common word, expect the occasional miss.

It also doesn't currently track Google AI Overviews or AI Mode, only the standalone chat assistants. If a chunk of your traffic comes through Google's AI summary box specifically, this tool won't see that yet. It's on my list, not on the product today.

And it's a young product built by one small team, not a funded company with a research arm. If you need a dozen locations tracked daily with a dedicated customer success rep, that's a different price bracket and a different company.

Who should use it, who shouldn't

If you're a solo founder or small team who wants a rough, honest signal on whether AI assistants are recommending you over the competition, and you don't want to pay $99-800/month to find out, this is built for exactly that. Start on the free plan, watch it for two or three weeks, decide from there.

If you need enterprise-grade coverage across a dozen models and locations, or you specifically need Google AI Overview tracking today, look elsewhere for now, or check back in a few months, because that's roadmap territory for me.

What's next

The parsing engine is the priority. After that: better competitor alerting so you get pinged the moment a rival overtakes you in an answer, instead of noticing it yourself three days later. I'd rather ship those two things solid than pile on features nobody asked for.

If you want to see where you actually stand, AskAiRank has a free plan, no card required. I'd genuinely like to hear where it breaks for your product.

9 Best Tools to Track Your Brand Mentions in ChatGPT and Other LLMs

Admin Supafast — Sun, 16 Aug 2026 14:28:34 +0000

I spent a weekend grepping server logs trying to figure out why a chunk of new signups had no referrer, no UTM params, no search query attached at all. They just appeared, direct traffic with zero context. Tracing a few back through support conversations, the pattern was obvious: people had asked ChatGPT or Perplexity for a recommendation, gotten our product name, and typed the URL in by hand.

That's not a traffic source any analytics stack is built to catch, because there's no click to attribute. So I went looking for tools that measure, systematically, whether and how often language models mention a given brand. This category (AEO, GEO, "AI visibility," pick your term) turned out to be small, fast-moving, and priced all over the map.

How this actually works under the hood

Worth understanding the mechanism first, because it explains the pricing spread and why you should distrust any tool promising a precise "rank."

There's no API for "what position am I in ChatGPT's answer to X." Every tool here does some version of the same thing: run a bank of representative prompts against model APIs (or automate the consumer chat UIs, riskier and against most providers' terms) on a schedule, parse the completions for brand names and citations, then aggregate that into a visibility score or share-of-voice metric over time.

Two implications worth knowing before you buy:

Model coverage drives cost almost linearly. Every extra model (GPT class, Claude, Gemini, Perplexity's retrieval layer, DeepSeek) means a separate API contract, separate rate limits, and separate parsing logic, since citation formats differ per model.
Sampling is inherently noisy. Same prompt, same model, different day (or the same minute at nonzero temperature) can produce different brand mentions. Good tools sample repeatedly and report trends; weak ones show a single run and call it a score. Treat any number here like a flaky test suite: one red run doesn't mean the build is broken.

With that context, here's what I found after testing or reading through the pricing and docs of about a dozen tools. Full disclosure: I built the first one, AskAiRank. Included on merit, but weigh accordingly.

1. AskAiRank (I built this one)

AskAiRank runs your buyers' actual prompts against ChatGPT, Claude, Perplexity, Gemini, and a handful of other models, then scores how often and how favorably your brand shows up versus competitors.

Free plan covers one brand across 10 prompts on ChatGPT and DeepSeek, no card required, which is enough to sanity-check whether you're worth tracking at all. Paid starts at $19/month; $39/month unlocks all 8 models we support. No enterprise-gated features hiding behind a "contact sales" wall.

2. Otterly.ai

Otterly has been in this space longer than most and keeps its pricing genuinely accessible. The Lite plan is around $29/month for 15 prompts across four engines, with unlimited team seats included, which is unusually generous for the price point.

Good first tool if you've never measured AI visibility before and want a clean dashboard without a lot of configuration overhead.

3. Waikay

Waikay ships a free tier and keeps the UI opinionated: instead of a wall of charts, it surfaces a short list of concrete fixes. Less raw data, more "do this next."

Fits founders who'd rather get a to-do item ("add a comparison page") than interpret a graph themselves.

4. Nightwatch

Nightwatch started as a conventional rank tracker and bolted AI visibility onto its existing local SEO stack as an add-on module. Base plan runs about $32/month; the AI visibility layer pushes the total to roughly $131/month.

Makes sense if you're already inside Nightwatch for regular SEO tracking and want one bill instead of two subscriptions covering adjacent things.

5. Peec AI

Peec is built for SMBs and agencies, with guided onboarding and roughly $95-99/month for 50 prompts and a choice of three out of six supported models, unlimited seats included. Decent middle ground between the cheap tier's narrow coverage and the enterprise tools' everything-included pricing.

6. Profound

Profound is the name that comes up constantly in AEO conversations right now. It closed a large Series C in early 2026 and lists hundreds of enterprise customers. Pricing starts at $99/month (Starter), climbs to $399/month (Growth), and goes custom above that for enterprise contracts.

Overkill for a bootstrapped project, but worth knowing about since it's the tool your investors or advisors are most likely to have heard of.

7. Scrunch

Scrunch targets mid-market teams and explicitly covers every major model, including Claude, which a few competitors either skip or gate behind a higher tier. Starter pricing sits around $250-300/month.

Makes sense once you're past the bootstrap stage and need broad, uniform model coverage without stitching together multiple vendors.

8. Semrush AI Toolkit

If you already have a Semrush subscription, the AI Visibility Toolkit adds brand tracking across ChatGPT, Gemini, Perplexity, and Google AI Overviews for about $99/month per domain on top of your existing plan. It pairs share-of-voice tracking with content recommendations aimed at the kinds of pages that tend to get pulled into AI answers.

A reasonable bolt-on if you're already living in the Semrush ecosystem. A harder sell as a standalone purchase.

9. Ahrefs Brand Radar

Ahrefs added AI visibility as an add-on to its suite, and it's the most expensive option here by a wide margin: $199/month per AI platform index, or $699/month for all six bundled, stacked on top of an active Ahrefs subscription. Realistic full-coverage cost lands north of $800/month.

The tradeoff for that price is breadth: it also tracks Reddit, YouTube, and TikTok mentions alongside the AI engines, something nothing else on this list does.

What I'd actually pick

If you're a solo dev or small team validating whether this matters at all, start with a free tier (AskAiRank or Waikay) or a cheap tool (Otterly) before evaluating anything in the $99-800/month range. You don't need six models sampled daily at launch. You need a repeatable signal: are you showing up when someone asks a model about your category, and is that trend moving up or down over a few weeks.

Once that signal is worth acting on, and once a few hundred dollars a month is a rounding error rather than a real line item, the mid-market and enterprise tools make more sense. Until then, treat this like any other noisy-signal monitoring problem: sample cheaply, sample often, and don't overbuild instrumentation before you know the thing you're instrumenting is worth the attention.

Controlling a treadmill from an iPhone over Bluetooth LE

Admin Supafast — Mon, 10 Aug 2026 16:06:32 +0000

Most treadmills have a Bluetooth chip and a companion app nobody enjoys using. I wanted to drive the treadmill - speed, incline, live stats - from a clean SwiftUI app instead. That became Treadmill Pro, an iOS app that talks to the treadmill directly over Bluetooth Low Energy with CoreBluetooth. Here's what building a BLE hardware controller actually involves.

BLE in one paragraph

A BLE device exposes services, each containing characteristics you can read, write, or subscribe to. Fitness equipment often speaks FTMS (the Fitness Machine Service), a standard set of characteristics for treadmills, bikes and rowers. In practice, support is uneven - some machines follow the spec, some ship their own quirks - so you discover services at runtime and adapt.

The connection lifecycle

The unglamorous truth of BLE is that most of the work is state management:

Scan for peripherals advertising the right service.
Connect and discover services and characteristics.
Subscribe to the ones that stream data (speed, distance, time).
Write to the control characteristic to change speed or incline.
Handle disconnects - devices drop, users walk out of range, sessions end.

Every one of these steps can fail or stall, so the app is really a state machine with a treadmill on the other end.

Reading stats vs sending commands

Two directions, two different concerns:

Reading is a subscription: the treadmill pushes notifications and you decode the bytes into speed, distance, time, calories. The decoding has to match the characteristic's data layout exactly.
Writing is a control request: you send a command to set speed or incline. Many machines require a "take control" handshake before they accept commands, and you have to respect their allowed ranges.

Lessons from talking to hardware

Assume the spec is a suggestion. Real devices deviate. Log raw packets and be defensive when decoding.
Make the state machine explicit. Scanning, connecting, connected, reconnecting - model them directly instead of juggling booleans.
Never trust the connection. Design for the treadmill vanishing mid-run; recover gracefully instead of hanging.
Keep the UI responsive during BLE work. Connection and discovery are async; the interface should always show what's happening.

Takeaways

BLE hardware apps are less about the flashy UI and more about robust connection handling and correct byte decoding. Get the state machine and the parsing right and the rest is easy.

The app is at https://treadmillpro.app

If you've worked with CoreBluetooth or FTMS, I'm curious how you handle devices that ignore the standard - do you maintain per-device quirks, or try to stay generic?

Rendering a live 3D earthquake globe on iOS from the USGS feed

Admin Supafast — Mon, 10 Aug 2026 15:53:44 +0000

I wanted to see earthquakes the way they actually happen: as points lighting up on a spinning planet, in near real time. That became Earthquake: Live Seismic Monitor, an iOS app that renders a 3D globe of recent quakes straight from the USGS feed. No backend of my own - just the public data and the device. Here's how it comes together.

The data source

The USGS publishes earthquake data as GeoJSON feeds, updated continuously, at several time/magnitude cutoffs (past hour, past day, 2.5+, 4.5+, etc). Each feature has coordinates, magnitude, depth and time. That's everything you need to place a quake on a globe - no custom API required.

The app polls the appropriate feed, diffs against what it already has, and updates the scene. Because USGS does the heavy lifting, the whole thing is effectively serverless from my side.

Putting quakes on a globe

The core mapping problem is turning (latitude, longitude) into a point on a sphere. Once you have that, each earthquake becomes a marker whose size and color encode magnitude and depth, so a glance tells you "big and shallow" vs "small and deep".

Design decisions that mattered:

Encode magnitude visually. Radius and color do more than any label. A magnitude 6 should look like a magnitude 6.
Cluster sensibly. Active regions produce swarms; markers need to stay readable when dozens land in one area.
Keep the globe interactive. Rotate, zoom, tap a quake for details. It should feel like an object, not a chart.

Real-time without a server

Every network-dependent app has to answer: what happens offline, and how fresh is "live"? My rules:

Cache the last good feed so the globe still renders with no connection.
Refresh on foreground and on an interval, and show the data's own timestamp so "live" is honest.
Never block the UI on the network - render what you have, then update.

Why no backend

It's tempting to proxy the feed through your own server "for control". But USGS is reliable, public, and built for exactly this. Skipping a backend meant no servers to run, no scaling to worry about, and no place for me to introduce staleness. The device talks to the source directly.

Takeaways

Great public datasets (USGS here) can carry an entire app - look for them before building infrastructure.
Encode the important variable (magnitude) into shape and color, not text.
Be honest about "real time": show the source timestamp instead of implying instant.

The app is at https://earthquakes.site

If you've built globe or map visualizations, I'd love to hear how you handle dense clusters of points without the map turning to mush.

Generating daily horoscopes and zodiac videos with an automated AI pipeline

Admin Supafast — Mon, 10 Aug 2026 15:47:33 +0000

Astrology content has a brutal property: it has to be fresh every single day, for every sign, ideally in a few languages, forever. Writing that by hand doesn't scale. For AstroZodify I built a pipeline that generates daily horoscopes and short zodiac videos on a schedule, with humans reviewing rather than writing. Here's the shape of it.

The content problem

Per day you need: 12 signs x N content types (daily horoscope, love, career) x M languages. That's hundreds of pieces of copy a day that all have to feel written, not templated, and stay consistent with each sign's "voice".

Templating alone reads robotic. Free-form generation drifts. The trick is constraining an LLM enough to stay on-brand while still sounding human.

The generation pipeline

Structured prompts per sign. Each sign has a persona and constraints (tone, themes, length). The model fills the daily specifics, not the whole thing from scratch.
Scheduled batch runs. A cron job kicks off generation ahead of time so content is ready before it's needed, never on the critical path of a page request.
Validation. Output is checked for length, banned phrasing, and structure before it's allowed near the site.
Store, then serve. Everything lands in Postgres. Pages are SSR and just read pre-generated rows, so the LLM is never in the user's request path.

Keeping generation offline from serving is the single most important decision - it keeps pages fast and costs predictable.

Adding video

Text was step one. Short vertical zodiac videos (for social) are step two, and that's a heavier pipeline: script -> imagery -> voiceover -> render. That part runs on Cloud Run as a separate job so a slow render never touches the web app, and we pilot one item before any batch.

Cost and safety rails

Anything that calls a paid API in a loop is a footgun. The rules I follow:

Always pilot on 1-10 items before a full batch.
Never an unbounded loop against a paid API.
Cache and pre-generate so serving is basically free.

Takeaways

Separate generation from serving. Pre-generate on a schedule, serve static rows.
Constrain the model with per-entity personas instead of free-form prompts.
Treat video as its own isolated pipeline, not an extension of the text one.

You can see the output at https://astrozodify.com

If you're generating large volumes of scheduled content, I'd love to compare notes on validation - how do you catch a bad generation before it ships?

Building an AI translator that lives everywhere on macOS, iOS and Chrome

Admin Supafast — Mon, 10 Aug 2026 15:43:24 +0000

Most translation tools make you leave what you're doing: copy text, switch to a tab or app, paste, read, copy back. I wanted translation to sit inside whatever I was already using. That turned into Linguin, an AI translator with a native Mac app, an iPhone app, and a Chrome extension. Here's how I think about building the "same" product across three very different surfaces.

One idea, three surfaces

The product promise is identical everywhere: select text, get a fast, context-aware translation in 100+ languages. But the interaction has to be native to each platform, or it feels wrong:

macOS: a menu-bar app plus a global hotkey. Select text anywhere, hit the shortcut, get an overlay. The whole point is that you never switch apps.
iOS: a share-sheet extension and keyboard, so translation is one tap from any app instead of a context switch to a separate screen.
Chrome: an extension that translates selections and full pages in place, keeping layout intact.

Same core, three genuinely different UX shells.

Keeping the core in one place

The translation logic - language detection, prompt construction, tone handling, caching - is the part you never want to fork. If Mac and iOS drift, you get subtly different translations for the same input, which erodes trust fast.

So the model-facing logic lives behind one small service contract, and each client is a thin shell that owns only its platform UX. A translation request looks the same whether it comes from the menu bar, the share sheet, or a browser selection.

Why "AI" translation instead of a classic API

Classic MT is great at literal accuracy but blind to context. "Book" in a travel app and "book" in a library app should not translate the same way. Passing the surrounding context and a tone hint (formal, casual, technical) to an LLM produces translations that read like a human wrote them, not a dictionary.

The tradeoffs I had to design around:

Latency: users expect near-instant results, so caching and streaming matter a lot.
Consistency: same input should give the same output, so requests are normalized and cached aggressively.
Cost: batching and caching keep per-translation cost sane.

Lessons so far

Ship the platform-native interaction first. A technically perfect translation behind a clunky flow loses to a decent translation that's one keystroke away.
Centralize the model logic early, before the clients diverge.
Context and tone are where AI translation actually beats the old tools - lean into that, not raw language count.

If you want to try it, the Mac app, iOS app and Chrome extension are all at https://linguin.app

Curious how others structure a shared core across native + web clients - do you go with a shared service, a shared package, or just accept some duplication?

How I track whether ChatGPT, Claude and Perplexity recommend my product

Admin Supafast — Mon, 10 Aug 2026 15:41:37 +0000

When people look for software today, a growing share of them never touch Google. They ask ChatGPT, Claude, Perplexity or Gemini "what's the best tool for X?" and take the answer at face value. If your product isn't in that answer, you're invisible to those users, and you have no idea it's happening.

I kept running into this with our own products, so I built AskAiRank to measure it. This post is about the problem and how the tracking actually works under the hood.

The problem: AI answers are a black box

Classic SEO gives you rank trackers, Search Console, backlinks. For AI assistants there's almost nothing. You can't see:

Whether a model mentions your brand when asked about your category
Where you land relative to competitors in that answer
Which sources the model cites to justify its recommendation

And the answers aren't deterministic. Ask the same question twice and you can get different tools, different ordering, different citations. So a single manual check tells you nothing, you need to sample over time.

How the tracking works

The core loop is simple:

Prompts. You define a set of buyer-intent prompts for your category, e.g. "best AI translation app for Mac" or "tools to monitor earthquakes".
Run across models. Each prompt is sent to ChatGPT, Claude, Perplexity and Gemini on a schedule, so we sample the distribution rather than a single roll.
Parse the response. For each answer we extract brand mentions, their position in the list, sentiment, and any cited source URLs.
Score and compare. Mentions and positions roll up into a visibility score per model, and you can add competitors to see share of voice.
Alert on drift. When your visibility drops or a competitor overtakes you, you get notified.

The parsing is the hard part. Model output is prose, not JSON, so mention detection has to handle aliases, partial names, "also worth checking out X" asides, and citations that live in footnotes or inline links. It's the piece I'm still iterating on the most.

Stack

Nothing exotic:

Next.js frontend
Self-hosted Postgres + PostgREST for data and API
Python workers that call the four model APIs and do the parsing/scoring
Scheduled runs so the sampling happens without anyone clicking a button

Why this matters (AEO / GEO)

People are starting to call this AEO (Answer Engine Optimization) or GEO (Generative Engine Optimization). The name matters less than the shift: recommendation is moving from ranked blue links to a single synthesized answer. If you ship a product, it's worth knowing where you stand in that answer, the same way you'd check your Google rank.

If you want to try it on your own product, there's a free plan (no credit card): https://askairank.com

I'd genuinely love feedback, especially from anyone who has tackled mention-detection in free-form LLM output. Where does your approach break?