DEV Community: Germán Aliprandi

The Anti-LLM Checklist: How I Made AI-Written Recruiter Messages Sound Human

Germán Aliprandi — Thu, 13 Aug 2026 02:57:54 +0000

If you've used an AI coding agent to draft messages, you know the problem. The output is easy to spot. Em-dashes everywhere. Bullet points in DMs. Polished paragraphs that no human would type in a LinkedIn message.

Recruiters get dozens of these. They can tell.

I built an anti-LLM checklist for recruiter replies as part of Job Seeker, an open source set of markdown skills that any coding agent (Claude Code, Cursor, Devin, opencode) consumes to search, apply, and track jobs. The checklist forces the agent to sound human before showing you the draft.

The checklist

Before any recruiter reply is shown to the user, the agent runs it through this checklist:

No em-dashes (—). Use commas, periods, or parentheses. Em-dashes are the #1 tell that something was AI-written.
No bullet points in chat/DM messages. Bullets are for docs, not LinkedIn messages. A human writes in flowing text.
Conversational tone, not formal/structured. A human doesn't write polished paragraphs in a DM.
Maximum 2 short paragraphs. If it's longer, it's over-explaining.
Don't mention company research in a way that sounds like it was googled 2 minutes ago. If mentioning something, make it natural.
Don't repeat JD keywords obviously. If the job description says "agent orchestration, RAG and evaluation strategies", don't parrot it back.
Mimic the user's previous messages for tone and length. If no style profile exists, mimic the recruiter's tone.

If the draft doesn't pass, the agent rewrites it before showing it to you.

Why this matters

The goal isn't deception. It's about not sounding like every other AI-written message a recruiter receives. When every message has em-dashes, bullet points, and structured paragraphs, the human-written ones stand out. And not in a good way for the AI-assisted ones.

The checklist lives in the Gold Rules (AGENTS.md) of the repository, so any agent that reads the repo follows it automatically. No config, no prompting, it's baked in.

How it works in practice

When the news skill detects a recruiter message (via Gmail or LinkedIn), it:

Extracts action items (calendar link? CV request? scheduling?)
Analyzes the proposal (company, role, salary if mentioned)
Researches the company
Drafts a reply that passes the anti-LLM checklist
Shows you the draft with analysis and action items
Waits for your approval before sending

You always approve before anything is sent. The agent does the drafting, you do the deciding.

The bigger picture

This checklist is one piece of Job Seeker, an open source project that turns any coding agent into a job search assistant. The agent searches LinkedIn with your preference filters, fills Easy Apply forms from your Postgres database, tracks applications in a kanban pipeline, and drafts recruiter replies that sound human.

It's MIT licensed, candidate-agnostic (no personal data in the repo), and works with any agent that reads markdown.

Links:

Repo: github.com/galiprandi/job-seeker
Docs: galiprandi.github.io/job-seeker

If you're using AI to write recruiter messages, try this checklist. It makes a difference.

I Open Sourced a Tool That Lets Your AI Coding Agent Apply to Jobs for You

Germán Aliprandi — Sun, 09 Aug 2026 02:29:49 +0000

After months of manually scrolling job boards and filling the same Easy Apply form 200 times, I decided to automate it. But not with a SaaS or a Chrome extension. With the coding agent I already use every day.

The problem

The average tech job seeker spends 5-8 hours per week on:

Searching LinkedIn with the same filters
Filling Easy Apply forms that ask the same 15 questions
Tracking applications in a spreadsheet that's always out of date
Drafting replies to recruiters while trying not to sound like a robot
Forgetting which companies they already applied to

The solution: skills, not code

I built Job Seeker, an open source set of markdown skills that any coding agent (Devin, Claude, Cursor, opencode) can consume. Your agent reads the skills, uses a playwright-cli wrapper for browser automation, and stores everything in a Postgres database.

It's not an agent. It's the instructions and scripts that make your agent a job search assistant.

How it works

You: "apply to 5 jobs"
  -> Agent loads your profile from DB
  -> Searches LinkedIn with your Must-have filters
  -> Applies via Easy Apply (form data from DB)
  -> Registers every application
  -> Shows you a summary

9 flows

Flow	What it does
onboarding	Browser setup, Gmail + LinkedIn login, DB creation
profile	CV extraction + 30-preference questionnaire with Must/Strong/Nice weights
strategy	passive/selective/active/aggressive levels
apply	LinkedIn search + Easy Apply
news	Gmail + LinkedIn inbox review, draft replies
daily	Runs news + apply automatically
radar	Register on job boards, set up alerts
targets	Apply directly to 40 target companies
memory	Autonomous preference detection and storage

Key design decisions

1. Skills as markdown. Any agent that reads markdown can use them. No vendor lock-in, no API keys, no SaaS dependency.

2. Candidate-agnostic repo. No personal data in any tracked file. Everything lives in your own Neon Postgres DB. Clone, run onboarding, done.

3. Browser isolation. Dedicated Chrome profile via playwright-cli wrapper. Headless by default, headed only for manual login and 2FA. The agent never handles credentials.

4. Strategy levels. passive, selective, active, aggressive. Each controls batch sizes, frequency, match thresholds, and which Must-haves to relax. Pick a level and all flows respect it.

5. Anti-LLM messages. Recruiter replies pass a checklist: no em-dashes, no bullet points in DMs, conversational tone, max 2 short paragraphs, mimic the user's style profile from DB.

6. Form data from DB only. The agent never invents values. If a field is missing, it stops, asks the user, saves the answer, and continues.

Try it

git clone https://github.com/galiprandi/job-seeker.git
cd job-seeker
npm install

Create a .env with your Neon Postgres connection string, then tell your coding agent: "run the onboarding skill."

After onboarding: "apply to 5 jobs" or "check for updates."

Introducing react-tools: A Toolbox for Streamlining React Development

Germán Aliprandi — Fri, 24 May 2024 01:56:18 +0000

Introducing `@galiprandi/react-tools`: A Toolbox for Streamlining React Development

Are you looking to simplify your React development process? Look no further than @galiprandi/react-tools. This comprehensive package offers a range of intuitive utilities designed to enhance your React applications. Let's explore some of its key components and hooks:

Playground

Before diving into the details, why not take a test drive? Visit the @galiprandi/react-tools Playground to experiment with the components firsthand.

Installation

Getting started is a breeze. Simply install the package using your preferred package manager:

npm i @galiprandi/react-tools

pnpm i @galiprandi/react-tools

yarn add @galiprandi/react-tools

Components

`<Form />`

Simplify form creation with the <Form /> component. This component wraps the form HTML tag, offering a straightforward approach to building forms in your React application. Additional props like onSubmitValues and filterEmptyValues provide enhanced functionality.

`<Input />`

Enhance user input experiences with the <Input /> component. This reusable input wrapper adds consistency to your forms and accepts various props for customization, including label, onChangeValue, and debounceDelay.

`<DateTime />`

Need date and time input functionality? Look no further than the <DateTime /> component. This wrapper around the native input element with type="datetime-local" offers convenient date selection with additional props for customization.

`<Dialog />`

Create accessible dialogs and modals effortlessly with the <Dialog /> component. This wrapper around the dialog HTML tag simplifies dialog creation, with options for defining behavior, callbacks, and content.

`<Observer />`

Track element visibility with the <Observer /> component. Whether you're implementing lazy loading images or infinite scrolling, this component offers a straightforward solution for monitoring viewport interactions.

Hooks

`useDebounce()`

Streamline asynchronous operations with the useDebounce() hook. This simple yet powerful hook accepts a value and delay, returning a debounced value to optimize performance.

Contribution

Your contributions are valuable! Whether it's bug fixes, feature enhancements, or documentation improvements, contributions are welcome. Simply fork the repository, make your changes, and open a pull request.

License

@galiprandi/react-tools is licensed under the MIT License, providing flexibility for both personal and commercial use.

Ready to simplify your React development workflow? Install @galiprandi/react-tools today and experience the difference firsthand. Happy coding!

💡 La clave del desarrollo frontend eficiente: Composición sobre Programación

Germán Aliprandi — Wed, 22 May 2024 17:48:10 +0000

Cuando iniciamos el desarrollo de aplicaciones frontend, el primer paso crucial es la programación. Este es el momento en el que sentamos las bases, diseñamos los componentes y establecemos la lógica fundamental.

Sin embargo, una vez que esta fase inicial está bien hecha, la verdadera magia comienza. En lugar de continuar programando desde cero cada nueva funcionalidad, el enfoque debe cambiar a componer. ¿Qué significa esto?

🔹 Componentes Reutilizables: Si hemos creado nuestros componentes de manera modular y reutilizable, podemos ensamblar nuevas funcionalidades simplemente combinando estos bloques de construcción existentes.
🔹 Escalabilidad y Mantenimiento: Este enfoque no solo acelera el desarrollo sino que también facilita el mantenimiento y la escalabilidad de la aplicación. Cambios en la lógica o el diseño se pueden implementar más fácilmente sin romper todo el sistema.
🔹 Eficiencia y Calidad: La composición nos permite enfocarnos en mejorar y optimizar las piezas existentes, garantizando una mayor calidad y coherencia en toda la aplicación.

Una forma de saber si hemos hecho bien nuestro trabajo es observar que, a medida que el proyecto madure y avance, cada vez programaremos menos y compondremos más, reutilizando las piezas de software que decidimos crear al comienzo del proyecto.

Así que, al diseñar tus aplicaciones frontend, dedica el tiempo necesario a la fase inicial de programación. Un buen cimiento permitirá que en el futuro, tu desarrollo sea más sobre ensamblar y menos sobre programar desde cero. La eficiencia y la calidad de tu software te lo agradecerán.

¿Qué opinas sobre este enfoque? ¿Cómo has manejado la composición y programación en tus proyectos? ¡Me encantaría leer tus experiencias!