A post titled "AI Can Make You Suck Faster Too" hit the Hacker News front page this week and racked up 114 points and 116 comments fast. The claim underneath the provocative title holds up under scrutiny: AI can make you suck faster, but only in the specific case where you use it to skip the checking step instead of the typing step.
Short answer: Yes, AI can make you suck faster, according to the Hacker News debate around writer Jordan Andersen's $10 DeepSeek coding experiment. The risk isn't the tool — it's skipping verification. Read AI output like it came from a stranger, check its sources before acting on them, and test small before you commit real time or money to what it recommends.
Last updated September 1, 2026.
I spent the afternoon reading Jordan Andersen’s original post and the full 116-comment HN thread it spawned, then ran the same kind of small, cheap experiment he describes against a couple of the AI tools I already use for client work. In my testing, his core complaint held up: a model will hand you code that runs while quietly loading it with the equivalent of duct-taped wheels, and it will do that with the same confident tone it uses when it's actually right. That confidence gap, not the tool itself, is what turns "AI helped me ship faster" into "AI helped me ship something broken faster."
What you'll need
You don't need to give up your AI tools to get through this. You need the AI tool you already use — ChatGPT, Claude, DeepSeek, Cursor, whatever's in your regular rotation — plus about five extra minutes per answer you're actually going to act on, not every throwaway question. A way to check a claim independently helps too: a search engine, a colleague who knows the domain, or the AI's own cited source, which you should actually open rather than take on faith. None of this costs anything beyond the time.
Step-by-step: catch it before it costs you
1. Ask for the source, then open it
When an AI tool states something as fact, ask where it got that, and click through. Semrush’s 2025 study of ChatGPT’s citation patterns found Reddit gets cited in 176.89% of finance queries — meaning it shows up nearly twice per answer on average — ahead of the licensed financial sources that YMYL guidelines say should rank first. When I tested finance and health questions the same way, the pattern matched: the source behind a confident answer was frequently a forum post, not the primary document it should have pulled from.
2. Spend small before you spend big
Andersen's experiment is more useful as a method than as a verdict: he put $10 into DeepSeek credits on a real project instead of taking a vendor's word for the productivity claims. That's the right instinct even if $10 is too small a sample to prove much on its own, which is exactly what several HN commenters pointed out in the thread. Before you commit a client budget or a week of your time to an AI-driven plan, run the cheapest version of it first and read the result closely.
3. Read the output like it came from a stranger
Don't skim AI-written code, copy, or analysis faster than you'd review the same thing from a new hire whose judgment you haven't tested yet. In my testing, the mistakes I missed were never in output I read line by line — they were in the parts I approved because the tone was confident and the surface looked clean.
4. Weight your scrutiny by the stakes, not the topic
A wrong answer about a movie's release date costs you nothing. A wrong answer about wiring a circuit, dosing a medication, or structuring a contract can genuinely hurt you. Andersen makes this point with an electrical-wiring analogy: most people wouldn't rewire their own breaker box off a chatbot's steps, so the same caution belongs on any AI answer with a real financial, legal, or physical consequence attached.
5. Get a second, non-AI opinion when something breaks the pattern
If an AI's advice would surprise a person who actually knows the field, that's the moment to check with one before you act. One HN commenter, posting as Gigachad, described becoming what they called a "negative 10x developer" — spending a day a week undoing a non-technical manager's Claude Code changes before they reached production. That's what happens when step 5 gets skipped entirely.
Example prompts you can copy
These are built to surface the source and the confidence level behind an answer, not just the answer itself:
- "Give me the source for that claim, and tell me whether it's the primary document or something citing another site."
- "Rate your confidence in this answer from 1 to 10, and tell me specifically what would lower it."
- "What's the strongest argument against the answer you just gave me?"
- "If a domain expert reviewed this, what's the first thing they'd flag as wrong or oversimplified?"
- "What's the cheapest, smallest way I could test this before I commit real time or money to it?"
Prompt 2 is the one that changes behavior fastest — a model that rates its own answer a 4 out of 10 is telling you something a fluent, confident paragraph never will.
Common mistakes to avoid
The mistake that shows up most in the HN thread itself is judging the entire category off one small experiment — Andersen's $10 DeepSeek test, or, just as easily, one great result from a $20 Claude Code subscription. Neither proves much alone. Second, treating a model's tone as a proxy for accuracy, since AI writes with the same fluent confidence whether the underlying claim is solid or fabricated. Third, applying less scrutiny on unfamiliar topics than familiar ones, which is backwards — you catch mistakes in your own domain almost automatically and need the checking habit most exactly where you can't. Fourth, letting an AI-generated change reach production, a client, or a public post without the same review a human's work would get, which is the specific failure the "negative 10x developer" story above describes. Fifth, reading "AI can make you suck faster too" as a reason to stop using AI tools altogether, when the actual fix is cheaper and smaller: check sources, test small, and read closely before you act.
Tools that make this easier
If your version of this problem is specifically AI-written code, my disciplined workflow for AI coding covers the spec-first, small-diff habits that catch exactly the "runs but fragile" output Andersen describes, and my deeper look at whether coding expertise collapses from AI reliance covers the skill side of the same risk. If you're choosing a coding assistant in the first place, start with my AI coding assistant guide or the head-to-head in Cursor vs. Copilot. Since DeepSeek is the tool at the center of Andersen's experiment, how to use DeepSeek for coding walks through setup and where it's genuinely strong. And if you want to know how I test AI tools generally before recommending them, how we test AI tools and how to read an AI tool rating without getting fooled cover the process behind every review on this site.
Where blind trust in AI actually costs you
The risk isn't the same size in every use case. Here's roughly how it breaks down, based on the thread, the Semrush data, and my own testing across a few categories:
| Use case | How the risk shows up | Quick check before you rely on it |
|---|---|---|
| AI-written code | Runs, but fragile or insecure under real load | Read every diff; run the linter and tests before merging |
| Finance questions | Reddit outranks licensed financial sources 176.89% of the time in ChatGPT answers | Cross-check against a primary source — an official filing, prospectus, or bank page |
| General research | A fluent "good enough" answer replaces reading multiple sources | Ask for the source and open it before repeating the claim |
| Domain how-to (electrical, medical, legal) | Plausible steps with a real physical or financial downside if wrong | Get a licensed human for anything with a real consequence attached |
My take
I don't think AI is making people worse at their jobs by default — the HN pushback on Andersen's post is fair on that point, and a $10 experiment genuinely isn't enough evidence to write off a whole category of tools. What I do buy is the narrower claim: the exact habit that makes AI feel fast — accepting fluent output without checking it — is the same habit that lets a bad answer through, and it compounds the same way in either direction. Use AI to go faster on the typing. Don't let it talk you out of the checking.
Frequently Asked Questions
Is checking AI's answers before trusting them actually free?
Yes. Asking for a source, rating the model's own confidence, or opening a citation costs nothing beyond the extra few minutes it takes. The habit is free; skipping it is what gets expensive later.
How long does it take before AI reliance actually hurts you?
It can happen on the first unreviewed answer you act on — there's no warm-up period. The damage compounds the more often you skip the check, which is why the HN thread's "negative 10x developer" story describes a recurring weekly cleanup, not a one-time mistake.
What's the easiest way to tell when AI is wrong?
Ask it to rate its own confidence and name what would change that number. A model that can't point to a real source, or hedges the moment you push back, is telling you to verify before you act — even though the original answer sounded just as fluent as a correct one would.
Does this mean I should stop using AI tools?
No. Andersen's own post and the pushback under it both land on the same conclusion: the tools aren't the problem, using them to skip verification is. Keep the AI for speed and keep a human check for anything with real stakes attached.
Is the "10x productivity" claim behind all this actually true?
Not proven either way by a single experiment. Andersen's point about missing AI-era Airbnbs, Stripes, and Dropboxes is a fair observation, not a study — several commenters noted a $10 DeepSeek test is too small to settle the bigger question, and they're right. Treat sweeping productivity claims with the same source-checking habit this guide covers.