Hacker Newsnew | past | comments | ask | show | jobs | submit | sneefle's commentslogin

I posted a version of this a few months ago that was just "a bot that applies to jobs". The thing I actually spent the time since on is narrower and, I think, the only interesting part: checking whether the application arrived.

The failure mode that pushed me into it: a submit that returns a cheerful success page but never registers. The form silently drops the file, or the endpoint 400s behind an XHR and the SPA renders the confirmation anyway. From the outside those look identical to a successful application, so you sit there for three weeks assuming you were passed over.

So after the submit we go back and look for evidence the other side produced, not evidence we produced. "We clicked the button" is worthless, it is just reading back our own input. What counts is a confirmation email to the relay address, the application appearing in the ATS's own tracking, that kind of thing. We show three states rather than one: landed, still verifying, did not land.

It applies on the employer's real ATS (Greenhouse, Lever, Workday, Ashby, iCIMS, SmartRecruiters) via a cloud browser rather than emailing a PDF somewhere.

The honest part: the third state is not rare. Building it made my own numbers look considerably worse, and I still think showing it is the right call, but I go back and forth on whether a smaller confirmed number reads as more trustworthy or just as a weaker product. Genuinely interested in what people here think about that specific tradeoff.

Happy to go into the verification signals in detail if that is the useful bit.


we run screen-driven agents against web forms in production and the failure mode that took us longest to find wasn't navigation, it was commits that don't commit. a react controlled select can render the right value after a click while the framework's internal state never updated, so every pixel says done and the submitted payload says null. vision-only verification passes because the screen genuinely looks correct.

curious how you handle that class without DOM access. screenshot-after-action catches missing UI feedback, but when the UI itself is lying about form state the only reliable tells we found were downstream: the confirmation page, an outbound request, an email arriving. do your verification events ever consume anything besides pixels, or do you lean on the human approval gates for the risky commits?


Great observation on the "commits that don't commit" failure mode. We ran into the exact same class of bug building document extraction for regulated financial workflows — turns out vision-only verification has a blind spot that shows up whether you're parsing a screen or a PDF.

In tax preparation, documents have a lot of "the screen lies" equivalents: a PDF renderer can display perfectly aligned columns while the underlying text layer has misaligned fields. We learned this the hard way when an OCR pipeline extracted "123 Main St" beautifully from a W-2 image, but the XML metadata had a completely different address. The screen looked right, the data was wrong.

Our approach was a second verification layer structurally independent from extraction: deterministic rules that reconcile AI output against the source document's known structure. For a W-2, that means cross-walking every box number against the IRS's published schema and flagging deviations — same principle as your "downstream tells" but formalized into a rules engine.

The key insight: in regulated domains, the verification layer must consume something structurally different from what extraction consumed. If both use the same pixel-based representation, they share the same failure modes. Using DOM state, API call logs, or document metadata schemas as the verification source catches the cases where "pixel says done, payload says null."

Defining explicit "verification invariants" (similar to Coasty's approach) has been the most practical defense — things like "total across all line items must equal reported total" or "taxpayer name must match across all documents in the return." Simple arithmetic checks that don't need AI but catch the expensive failure modes that vision alone misses.

Curious how Coasty handles multi-source reconciliation — e.g., when the data on screen needs to be verified against a separate document (like a PDF guidance doc) rather than just against itself?


Yep, this is a real failure mode, and screenshot-after-action alone does not solve it. A field can look populated while the application never commits the underlying value.

We try to define verification around the actual outcome of the task rather than the immediately preceding UI state. Depending on the workflow, that can mean checking the confirmation page, reopening the submitted record, verifying a status change elsewhere in the application, matching a generated reference ID, or confirming that a downstream artifact was created.

We can also verify against separate inputs such as a PDF, CSV, or another screen for example, confirming that the values entered into a portal match the source document and then checking the resulting record after submission.

Today, our core agent is screen-driven, so we do not claim that pixels can prove every hidden state transition. For high-consequence commits, the workflow should use explicit downstream invariants and, where those are unavailable, a human approval or review step. Longer term, we think verification should be able to consume whatever independent evidence the environment exposes, including network or application-level signals, rather than treating vision as the only source of truth but it will be quite slower.


The invariant we use is the downstream outcome, not the visual state. For a controlled select, that can be the request payload, confirmation state, or persisted record. I’m building AnnotateQA around capturing a real browser failure and creating that failing Playwright reproduction before any code changes, with a candidate PR left for human review. If you have a recent case, I’d be glad to try one.


Timing couldn't be more perfect, yes. Visibility and getting it in front of the people is proving to be a bit challenging atm only. so far, trying to push on LinkedIn and find direct leads for open-to-work folks. :D


Solo founder here. I sent 127 job applications last year and got 3 callbacks. My ATS score on my own resume came back at 34% on roles I was actually qualified for. That's the origin.

AI Applyd does three things:

1. Scores your resume against a job description using the same keyword / skill / semantic extraction that Greenhouse, Lever, Ashby, and Workday run. You get a number and the specific missing keywords.

2. Rewrites the resume bullets to hit the missing keywords. You approve every change. No AI-slop passthrough.

3. Submits the application through a real cloud browser session. Not a form sniffer. Login, file upload, multi-step screening questions, cover letter — the full flow.

Stack, since HN is here:

- Cloudflare Workers + D1 (Drizzle) for everything. One region, global edge. No Postgres, no Redis, no queue runner outside CF. - Hono for the API, TanStack Start for the web, Better Auth with D1 adapter. - OpenRouter as the AI gateway. Most flows on Gemini 2.5 Flash Lite ($0.10/$0.40 per M). Free models for background enrichment. - Browserbase for the browser sessions, Stagehand on top for LLM-guided actions. Login-required platforms are gated behind user-initiated connections so we never hold plaintext credentials. - Remotion for the landing page demo videos, rendered ahead of time. - Turborepo monorepo, Wrangler deploys, Cloudflare Queues + cron for the scraper orchestrator (12h refresh, concurrency 5, 5-min hard timeout per job).

Everything LLM is cost-tracked. I set a daily spend cap after I fat-fingered a prompt loop once and burned $40 before my alert fired.

Free tier: 20K starter tokens, 10 ATS scores/mo, 5 resume tailors, 5 cover letters, 1 AI apply/mo, 15 documents, 25 job listings. No credit card. Paid: $39/mo for up to 15 applies/day (100/mo) or $79/mo for up to 50/day (300/mo).

Two gotchas worth mentioning for anyone building similar:

- Stagehand v3 uses AsyncLocalStorage.enterWith() for its logger. That API does not work in CF Workers. I patched Stagehand with 'bun patch' to swap the logger to a passthrough. - Wiring Stagehand to OpenRouter via the {modelName, apiKey, baseURL} object form breaks on the second request because @ai-sdk/[email protected] has a broken isReasoningModel path for non-OpenAI endpoints. Use CustomOpenAIClient + llmClient instead.

Demo (90s): https://www.youtube.com/watch?v=rbet3wFpGak

Also live on Peerlist Launchpad Week 17 (runs through Apr 26): https://peerlist.io/firstexhotic/project/ai-that-applies-for...

Would love feedback on: whether the auto-apply flow breaks on any specific job platforms you've seen, whether the ATS scoring feels accurate, and whether 10 free scores is enough to decide if it's useful. Ask anything technical — I'll go deep on the architecture.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: