The AI Toolchain
A two-hour working session on the tools that actually move work forward — for developers, for managers, for job seekers, and for the people who test it all.
- 00:00Framing — the one rule that governs everything
- 00:10Module 1 · Developers — Claude Code, Cursor, Antigravity
- 00:45Module 2 · Managers — the four-layer stack
- 01:10Module 3 · Résumés — build, tailor, submit, track
- 01:40Module 4 · Testing — agentic QA that survives CI
- 01:55Close — homework and the 30-day plan
How to use this pack
Three documents, stacked into one
Read it whichever way the moment calls for. The same pages serve as a live script, a reference, and a follow-up kit.
| Layer | What it is | Use it when |
|---|---|---|
| Run of show | Minute-by-minute timing, with a demo and a lab in each module. | Facilitating live. |
| Module bodies | The substance: diagrams, decision rules, tool tables, honest verdicts. | Preparing, or reading after. |
| Appendix | Copy-paste prompt library, link index, 30-day plan. | The week after class. |
The tool is a fast, tireless intern with no judgment. Your job is to supply the judgment — a plan going in, a verifiable check coming out. Skip either and you generate impressive-looking waste.
Open the session with that rule, and return to it at every module boundary. It is the single idea that separates people who get value from these tools from people who ship confident nonsense faster than they used to. Every module below is the same loop wearing different clothes: plan → let the agent work → verify against something real.
What to have in front of you
- A laptop with a terminal, and a real repository you care about — not a toy project.
- A Claude subscription (Pro or above) or a Cursor subscription. Both is better; one is enough to participate.
- Your current résumé as a
.pdfor.docx, plus one job description you would genuinely apply to. - Node 18+ installed, for the Playwright section.
Pick the tool by its shape, not its brand
Three products dominate this space in July 2026, and they are genuinely different shapes rather than competing versions of the same thing. Choosing well starts with matching the shape to the task in front of you.
Claude Code: the layered mental model
Claude Code is a harness with distinct layers, and almost every frustration people report traces back to putting a rule in the wrong layer. Teach the layers first; the commands follow naturally.
The functionality people actually under-use
Plan mode — read-only exploration before anything gets written. Cycle permission modes with Shift+Tab. In plan mode Claude cannot edit; it delegates codebase research to the built-in Plan subagent so all that exploration stays in a separate context window, then presents a plan for your approval. Adopting this one habit changes outcomes more than any prompt-engineering trick. Separate exploration → planning → implementation into three distinct phases.
Checkpointing — the reason you can be bold. Every prompt you send creates a checkpoint automatically, and checkpoints persist across sessions. Press Esc twice (or run /rewind) to open the menu. Restore conversation rewinds the chat but keeps the code as it is now; Summarize from here compresses a bad side-quest into a summary while keeping early context intact; Never mind backs out. Because a rewind is always one keystroke away, you can let the agent attempt something ambitious instead of babysitting it.
Scheduling — three mechanisms, often confused.
| Mechanism | Where it runs | Use it for |
|---|---|---|
| /loop + cron tools | Inside a live session | Repeating a prompt, polling for a status change, one-time reminders while you keep working. |
| Desktop scheduled tasks | Claude Code Desktop | Recurring local jobs: a daily dependency audit, a morning briefing, a nightly review of yesterday's merges. |
| Routines | Anthropic-managed cloud | Autopilot work that must run whether or not your laptop is open — schedules, API triggers, GitHub events. |
Subagents — the highest-leverage feature almost nobody configures. A subagent is a fresh Claude instance with its own context window, its own tool permissions, and its own model; your main session receives only its final summary. The single most valuable use is boring and enormous: isolating high-volume output. Running the test suite, crawling docs, sweeping a large repo for call sites — all of that floods your main context and pushes you toward compaction. Delegate it.
You get three built-in agents for free: Explore (fast, read-only, for search and codebase understanding), Plan (research during plan mode), and general-purpose (exploration plus action). Explore and Plan deliberately skip your CLAUDE.md and git status to stay fast and cheap — so if a rule genuinely must reach them, restate it in the delegating prompt.
Three ways to invoke a custom subagent, escalating in force: name it in a sentence and let Claude decide; @-mention it to guarantee it runs for that task; or run the whole session as it, which replaces the default system prompt entirely.
Hooks — where a convention becomes a guarantee. Prompts persuade; hooks enforce. A hook is a shell script fired at a lifecycle event, and it cannot be talked out of firing. The canonical four:
- PreToolUse — the security checkpoint. Exit code
2denies the call. Block a raw SQL write, scan edits for secrets, reject anything you never want to run. - PostToolUse — run Prettier or your linter after every edit or write.
- Stop / SubagentStop — run the test suite when work finishes; tear down a database connection.
- SubagentStart — set up an environment before a specific agent begins.
Everything in Lab 1 comes down to two files. First, a CLAUDE.md at the repo root gives every session the same footing:
# CLAUDE.md ## Stack Next.js 14 (app router) + Fastify API + Postgres. Monorepo via pnpm workspaces. ## Conventions - Never edit generated files under /packages/db/generated. - All API routes validate with Zod; no raw req.body access. - Tests live beside source as *.test.ts. Run with pnpm test. ## Definition of done Lint passes, types pass, the touched test file is green.
Then a custom subagent — a markdown file with YAML frontmatter — that isolates a high-volume job so its output never touches your main context:
--- .claude/agents/test-runner.md --- name: test-runner description: Runs the suite and reports only failures + likely cause. tools: Bash, Read, Grep model: haiku --- Run pnpm test. For each failure, return the test name, the assertion that failed, and the one file most likely responsible. Do not paste passing output. Do not attempt fixes.
Now @test-runner after a change and your main session gets a three-line verdict instead of four hundred lines of Jest.
Cursor: getting the agent and model selection right
Cursor's advantage is editor-grade ergonomics and the widest model picker in a single tool. Its main failure mode is cost surprise, and the fix is understanding one distinction clearly: reserve frontier models for genuinely hard problems, and reach for Max Mode only when the issue is context, not intelligence.
The Cursor levers worth demonstrating live:
- Plan Mode — scope the change and get agreement before a single file is touched. Same discipline as Claude Code's plan mode.
- Rules — a project-level file encoding your conventions. This is Cursor's
CLAUDE.mdequivalent, and skipping it is exactly why people say the agent "doesn't understand our codebase." - Parallel agents — spawn several agents from one prompt, each with its own working set, model, and approval policy, then merge. Worth a demo, and worth a warning about review load.
- Background and cloud agents — long tasks that keep running while you edit in the foreground.
- Bugbot — agentic code review on pull requests, available as an add-on.
- MCP, skills, hooks, and the team marketplace — on Teams plans, internal rules and skills are shareable, which is how a convention becomes an org-wide default.
- Privacy Mode — turn it on before the first proprietary line is typed; Teams and Enterprise can enforce it org-wide.
Antigravity: when breadth beats depth
Google's Antigravity earns its place in a specific situation: many independent tasks, where the bottleneck is your attention rather than any single agent's capability. It launched November 2025 as an agentic IDE with an Editor View and a Manager surface — mission control for spawning, orchestrating, and observing multiple agents across multiple workspaces in parallel. Antigravity 2.0 shipped at Google I/O on 19 May 2026 and split the product into several surfaces, including the original IDE (still Google's recommendation for developers) and a programmatic SDK in research preview.
The idea worth stealing even if you never install it: Artifacts
Delegating work requires trust, and scrolling raw tool calls is a miserable way to build it. Antigravity's agents produce Artifacts — task lists, implementation plans, screenshots, browser recordings — that you verify at a glance and comment on like a document, and the agent incorporates the feedback without stopping. Whatever tool you use, insist on this shape: the agent's output should be reviewable as a deliverable, not as a transcript.
Developers
Three questions. Pick an answer to see why it's right.
Four layers, and a buying order that surprises people
Managers get sold AI differently from developers. Vendors pitch a single product that promises to run your whole week, and the pitch collapses on contact with reality — because a manager's work spans four distinct systems. Naming the layers makes the buying decision obvious.
The tools you asked about, assessed honestly
Smartsheet AI is the one to be careful about. Its AI features — Smart Summaries, AI-assisted formula generation, natural-language navigation, workflow suggestions — are bundled exclusively into the Enterprise plan. Pro and Business tiers include no AI at all. So "we'll get Smartsheet for the AI" usually means "we'll get Smartsheet Enterprise," which is a much larger conversation. The platform itself is excellent for spreadsheet-native finance, ops, and IT teams, and its security and onboarding are strong. Several AI features (Smart Agents, Smart Flows, Smart Columns) were still early-adopter or private beta as of late 2025 — verify general availability before signing. Smartsheet was acquired in 2025 for $8.4B by Blackstone and Vista.
The rest of the shortlist, sorted by the layer each one strengthens:
| Tool | Layer | Why a manager would want it |
|---|---|---|
| Gemini for Workspace | 2 + 3 | The obvious Copilot equivalent for Google-native orgs. Spans Gmail, Docs, Drive, Sheets, Slides, Meet. |
| Asana AI | 1 | AI is included from the Starter tier rather than gated to Enterprise — a real edge over Smartsheet for smaller teams. Best for marketing and ops; weaker on complex dependency chains. |
| Atlassian Rovo | 4 | AI search, chat, and agents across Jira, Confluence, and connected sources. The right answer if your engineering org already runs on Atlassian — it meets people where the data already is. |
| Granola / Fathom | 3 | Lightweight, low-friction meeting capture. Granola enhances notes you take yourself rather than sending a bot into the call — the least awkward option for sensitive 1:1s. |
| Fireflies / Otter | 3 | Cross-meeting search and analytics that suite copilots handle less well. Works across Zoom, Teams, and Meet rather than one ecosystem. |
| Notion AI | 2 + 3 | Strongest when Notion is already your team's doc and task home — action items land directly in existing databases. Priced as a per-member add-on. |
| NotebookLM | 4 | Underrated for managers. Upload a bounded set of sources — a vendor's docs, three competitor reports, last quarter's retros — and interrogate only those. Grounded answers instead of general knowledge. |
| Claude / Cowork | 4 | The reasoning layer for genuinely multi-step work: reorganization plans, hiring rubrics, analysis that spans many files and tools. |
Three manager workflows worth automating this week
The status report you currently write by hand. Replace the weekly manual roll-up. Whichever assistant sits closest to your data, the prompt shape is the same — point it at the board or the thread, ask for movement since last week, blockers, and what needs a decision, in that order.
The 1:1 you keep having the same version of. Capture 1:1s in Layer 3, then ask Layer 4 to look across a quarter of them: "Across my last eight 1:1s with this person, what themes recur that I haven't acted on? What have I promised and not delivered?" This is where meeting AI moves from convenience to genuine management improvement — the pattern only exists across time, and no human reliably holds it.
The meeting that should have been a document. Before you schedule a recurring sync, run the agenda through an assistant and ask it to produce the artifact the meeting would have generated. If it can produce a good-enough version, cancel the meeting and review the document instead. Managers reclaim more hours from this than from any AI feature in a project tool.
Capture lives in Layer 3; the insight lives in Layer 4. Feed the transcripts in and constrain the output so it stays honest:
# Paste 8 transcripts, then: Across these 1:1s with Priya (Jan–Mar), return three lists: 1. Recurring themes she raised more than once. 2. Commitments I made and whether the later notes show them done. 3. Two things she's ready for that I haven't offered. Quote the date + line for every claim. If a theme appears once, leave it out.
The value isn't summary — it's the second list. "You promised to unblock the staging access on Jan 14 and it's still open in March" is the sentence no manager holds reliably in their head, and it's the one that changes the next conversation.
Buying Layer 1 AI first is the most common and most expensive mistake here. An agent that summarizes a board is worthless if the board is stale — fix the data habit before you pay for the summary of it.
Managers
Three questions. Pick an answer to see why it's right.
The bottleneck is evidence, not volume
Start here, because it reframes everything that follows: the bottleneck in a modern job search is almost never application volume. People arrive believing they need to apply faster, buy a bot, and let it run. The evidence points the other way — volume is cheap and getting cheaper for everyone, which means it has stopped being a differentiator and started being noise.
The tool landscape, split by what it actually does
The category name hides a crucial split, and conflating these three groups is why people buy the wrong thing. Read this as three separate purchases, not one.
Group A — Builders and optimizers (you write, AI improves)
| Tool | Best for | The honest read |
|---|---|---|
| Jobscan | Keyword-gap analysis vs a specific posting | The most transparent match report — names exactly which terms are missing, adjusted for which ATS the target uses. A scanner more than a builder. Priciest of the group; free tier limited to a few scans a month. |
| Rezi | Strict ATS-safe construction | Audits against 23 formatting and content metrics and hard-blocks choices that break parsing. One gotcha: its default template uses a thin-bordered skills table some parsers misread — use the plain-text export for older systems. Lifetime pricing is cheap over a long search. |
| Teal | Running a whole pipeline | The most generous free tier in the category — unlimited résumés and job tracking, clean single-column PDF that parses reliably. Weakness is tailoring depth: testers found it suggesting the same generic phrases regardless of posting. Pair it with Jobscan for keyword work. |
| Kickresume / Enhancv | Design, when a human sees it first | Strong visual output, weaker ATS discipline. The right choice for referrals, portfolio roles, and creative fields where the document goes straight to a person. Wrong choice for a Workday portal. |
| Claude / ChatGPT direct | Bullet rewriting and evidence extraction | Free-to-cheap and better than most dedicated tools at the actual writing, because you can give it far more context. Requires you to own formatting. This is what Lab 3 uses. |
Group B — Autofill assistants (AI fills, you click submit)
| Tool | What it does | The trade |
|---|---|---|
| Simplify | Chrome extension autofilling forms across 100+ sites, plus a tracker | Autofill accuracy runs ~90% on Greenhouse and Lever, ~80% on Ashby, ~70% on Workday. You still click submit on every application — that's the point. Realistic throughput: 6–10 applications per active hour. The best free option in the category if your bottleneck is typing, not time. |
Group C — Auto-apply agents (AI submits on your behalf)
| Tool | Model | Assessment |
|---|---|---|
| JobCopilot | Server-side agent, 500,000+ career pages claimed | The strongest pure auto-apply agent in current comparisons, but no free tier. Targets company pages and ATS platforms rather than automating LinkedIn — the safer architecture. |
| Jobright AI | Matching + referral discovery + agent submission | Pick it when match quality and finding a referral path matter more than raw volume. US roles only. |
| LoopCV | Autonomous with an optional approval queue | The approval queue is the feature that matters — you review matches before anything is sent. Strong on European boards and direct recruiter outreach. |
| Sonara | Cheapest hands-off volume | Sends the same untailored résumé everywhere. Understand that before buying it. |
| LazyApply | Browser extension, mass submission via Easy Apply and Indeed | Caution Effective at pushing raw count. Appears on a public blacklist of risky LinkedIn plugins and sits below 2.5/5 on Trustpilot with documented reliability and billing complaints. Expect volume saved, not hit-rate lifted. |
The architecture that actually works: a tiered funnel
Replace "apply to everything" with a deliberate allocation of effort. Tier your targets, and let the level of automation scale inversely with how much you want the job.
Build it yourself: the master-profile pipeline
The most durable version needs no subscription. Build one structured record of your career, then generate every tailored document from it. Doing this deliberately beats every builder, because the quality ceiling is set by the richness of your source data — and only you have that.
Step 1 — The master profile
Create master-profile.json. Include far more than any single résumé would hold: every project, every metric, every technology, in raw form. Aim for three to five times the content of your actual résumé.
Step 2 — The tailoring prompt
Point any capable assistant at the profile plus a posting. This prompt is deliberately constrained, because the failure mode of AI résumé writing is fluent invention:
# INPUTS 1. master-profile.json — everything true about my career. 2. The job description, pasted below. # TASK a. Extract the 8–12 requirements the posting actually weights; separate hard requirements from nice-to-haves. b. For each, find the strongest matching evidence in my profile. Where I have no genuine match, say so. Never invent experience, never inflate a metric, never imply seniority I lack. c. Select and rewrite 4–6 achievement bullets, ordered by relevance. Use the posting's own vocabulary where it honestly describes what I did. d. Write a 2-sentence summary line for the top. e. List the gaps separately, so I can decide: cover letter, or skip. # CONSTRAINTS - Every bullet: action verb, specific technology, quantified outcome. - One page unless I have 10+ years of experience. - Plain text. No tables, no columns, no graphics. - If a claim can't be traced to my profile, do not write it.
The "after" survives all four steps of Figure 3.1: it carries keywords (payments, tokenization, edge), it reads as impact to a human in two seconds, and every number is one you could defend in the interview. The constraint that makes this possible is the raw metric sitting in your master-profile.json — the model can only sharpen what you gave it.
Step 3 — Verify before you send
Wrap the loop, exactly as with every other tool today:
- Parse test. Copy the text out of your finished PDF. If the order scrambles or content vanishes, the parser will see the same thing.
- Scan test. Run it through Jobscan or a free equivalent against the posting. Chase missing true keywords; ignore the score itself.
- Human test. Read every line aloud and ask: could I defend this in an interview? Anything you'd hesitate on comes out. This step is the entire ethical boundary of the module — it is not optional.
Résumés
Three questions. Pick an answer to see why it's right.
Agentic QA that survives CI
Testing is where the current generation of coding agents is simultaneously most useful and most dangerous. One sentence is worth writing on the board before anything else: AI moves the cost of writing tests, not the cost of maintaining them.
The workflow to teach: Playwright MCP
The fix for hallucinated selectors is grounding the agent in your actual application. The Playwright MCP server gives Claude Code or Cursor a live, controllable browser: the agent navigates your real app, reads the real accessibility tree, and generates locators that resolve because it watched them resolve.
Wiring the server takes about ninety seconds:
# add the Playwright MCP server to Claude Code claude mcp add playwright npx @playwright/mcp@latest
Then the authoring turn is plain English, and the agent grounds every locator in the live page:
# your prompt Write a Playwright test: log in as the seeded demo user, add the $19 plan to cart, and assert the cart total reads $19.00. Navigate the running app at localhost:3000 first, then write it. # what comes back resolves because the agent watched it resolve: await page.getByRole('button', { name: 'Add to cart' }).click(); await expect(page.getByTestId('cart-total')).toHaveText('$19.00');
What the workflow does well — and where it stops
- First-pass authoring from a plain-English description
- Debugging a failing test — the agent can watch it fail
- Refactoring selectors after a UI change
- Generating API tests from an OpenAPI spec
- Long multi-step flows where state accumulates
- Dynamic data that differs between runs
- Deep conditional branching
- OAuth and third-party redirect flows
Worth knowing independently of any vendor: Playwright now ships a planner / generator / healer agent workflow that formalizes the loop engineers already do by hand — explore the app, write a test, fix it when it breaks. Paired with ARIA snapshots (asserting against the accessibility tree rather than brittle CSS), this is the cheapest credible AI testing setup available, because it's open source and runs on the CI you already have.
When to buy a platform, and which shape
The vendor landscape looks chaotic until you sort it by architecture rather than marketing. Six shapes:
| Architecture | Representative tools | Choose it when |
|---|---|---|
| Open-source + agent | Playwright + MCP, Playwright test agents | You want tests in your repo, on your CI, with no vendor lock-in. The default starting point. |
| Low-code AI authoring | mabl, Testim, Functionize, Katalon, Virtuoso | Non-engineers author tests and selector healing is your main pain. Expect proprietary execution environments. |
| Natural-language executors | testRigor, Momentic | You want plain-English specs that execute and adapt without a scripting step. |
| Generated-Playwright pipelines | Checksum, Bugzy | You want AI generation but insist the output is standard Playwright code committed to your repo. |
| Behaviour-derived regression | Meticulous | You have real production traffic and want regression coverage generated from actual user behaviour rather than authored. Complements authoring tools; doesn't replace them. |
| Visual assertion layers | Applitools | Visual regression specifically. Integrates with Playwright, Storybook, and native mobile — the easiest thing here to adopt incrementally. |
| Managed service | QA Wolf | You want humans who learn your product to own creation, maintenance, and triage. A staffing decision more than a tooling one. |
200–1,000 tests with moderate churn: start on a free tier (Katalon) or add Healenium to an existing Selenium suite, and learn what healing can and can't do before committing budget. Visual regression is a different problem — reach for Applitools alongside a functional healing tool, not instead of one.
Testing
Three questions. Pick an answer to see why it's right.
The 30-day plan
One habit in the first fortnight, compounding leverage in the second. Everyone leaves with the same three tracks — developer, manager, job seeker — and does the ones that apply.
| Track | Week 2 — one good habit | Week 4 — compounding |
|---|---|---|
| Developer | Ship two custom subagents: one read-only reviewer, one high-volume isolator (tests or log sweeps). | Wire Playwright MCP. Write five real tests. Package the setup as a plugin so a teammate installs it in one command. |
| Manager | Write and run one agent brief from Lab 2. Measure the time it actually saved. | Review what you bought. Cancel anything unused after 30 days — this category makes shelfware easy. |
| Job seeker | Define your three tiers by name. List 5–10 Tier 1 companies and find one human at each. | Review your funnel data. Which tier produced interviews? Reallocate toward it and stop doing the rest. |
Copy-paste
Prompt library
Five prompts that carry across tools. Each encodes the same discipline: give the agent structure going in, demand something verifiable coming out.
"Map this repo for me. Give me the entry points, the three most-touched modules, the data flow between them, and the five files I'd need to understand to make a change safely. Cite file paths. Don't summarize files I don't need."
"Review this diff as a skeptical senior engineer who has to maintain it. Find the three weakest decisions, not the typos. For each, name the failure mode and the smallest change that removes it. If it's fine, say so plainly."
"Here's the bug and the stack trace. Before touching code, list three hypotheses ranked by likelihood, and the one cheap check that would confirm or kill each. Run the cheapest first. Report what you learned before proposing a fix."
"From these notes, extract only: decisions made, owners with due dates, and open questions blocking progress. Drop everything that's discussion without an outcome. Flag any decision that lacks an owner."
"Using master-profile.json and this job description, generate the eight questions I'm most likely to get and the specific project I'd cite for each. Then ask me the hardest one and push back on my answer until it's defensible."
Reference
Link index
Developer tools
- Claude Code documentationcode.claude.com/docs
- Features overview (the six layers)code.claude.com/docs
- Cursorcursor.com
Résumé & job search
- Jobscan — ATS keyword analysisjobscan.co
- Jobright AI — matching + referralsjobright.ai
- Simplify — autofill + trackersimplify.jobs
Testing
- Playwrightplaywright.dev
- QA Wolf — managed QAqawolf.com
- Applitools — visual regressionapplitools.com