80% of DEs Use AI on Take-Homes. Now What?

I got a take-home assignment last year that asked me to build a full ingestion pipeline, write unit tests, document everything in a README, and prepare a 15-minute presentation for a panel. Estimated time: "about 4 hours." I timed myself. It took 14. I submitted it, never heard back, and three weeks later saw the same role reposted with a higher title. That was annoying but not surprising. What's surprising is that the format itself is now collapsing, and the data engineer take home interview in 2026 is becoming a relic in real time.

Here's the number that should end the debate: 64% of companies explicitly ban AI on take-home assignments, yet 80% of candidates use it anyway. AI cheating on technical assessments doubled from 15% to 35% between June and December 2025, and in purely technical roles the detection rate hit 48%. The take-home doesn't measure what it used to measure. It measures who has the best invisible overlay app and who's willing to spend a weekend pretending they didn't use Claude.

The 80% Number Nobody Wants to Say Out Loud

Fabric analyzed over 19,368 live technical interviews between July 2025 and January 2026. The headline: 38.5% of candidates showed AI cheating signals. In engineering-specific roles, that number climbed to 48%. In sales? 12%. The tools doing the damage aren't subtle anymore. Dedicated cheating platforms like Cluely, Interview Coder, and Final Round AI (each with over a million users) render answer overlays below the video capture layer. Your Zoom screen share can't see them. Your proctor can't see them.

And here's the part that should terrify hiring managers: 61% of candidates using unauthorized AI scored above the passing threshold and advanced to the next round undetected. The ban isn't working. The detection isn't working. The format is dead; companies just haven't filed the paperwork yet.

81% of Big Tech interviewers openly acknowledge that candidates are cheating via AI. The interview community now treats async assignments as "signal death" rather than a "work sample," because you can't distinguish effort from orchestration.

Junior candidates (0-5 years) cheat at twice the rate of seniors. The cheating methods break down like this: 45% use dedicated AI assistants, 34% use ChatGPT voice mode, 18% use traditional tab switching, and 3% get live help from another person. The tab-switching crowd is almost quaint at this point.

10-20 Hours of Unpaid Consulting (That AI Finishes in 45 Minutes)

The take-home was already a bad deal before AI killed its signal. Industry consensus puts 4 hours as the threshold for a legitimate assessment. Anything beyond that is free consulting. And DE take-homes routinely blow past that: multiple data sources, schema design across SQL and NoSQL systems, comprehensive documentation, test suites, and a live presentation to a panel who may or may not have read your submission.

Completion rates collapse to 60-70% on uncompensated take-homes. The candidates you're losing are the ones who already have offers elsewhere. Companies that compensate candidates and provide clear requirements see 85%+ completion. The rest are filtering for people with enough financial runway to donate a weekend, not people who are good at the job.

"Being able to spend several hours on unpaid work is a privilege not everyone has." That's a diversity problem masquerading as a technical assessment. And now it's also a cheating problem masquerading as a technical assessment. Double whammy.

The cruel irony: with AI, those 14-hour take-homes now take 2 hours. But you still have to pretend it took 14, because the company banned AI. So you're not just doing unpaid work; you're doing unpaid theater.

How Companies Try to Detect AI Use (and Mostly Fail)

Detection is an arms race, and the detectors are losing. The current toolkit includes behavioral signal analysis (tracking 20+ simultaneous indicators like gaze patterns, typing bursts, response latency, and copy-paste patterns), stylometry (analyzing code style for AI fingerprints), and AI content detectors claiming 85-99% accuracy in benchmarks.

The problem: false-positive rates sit at 1-3%. That sounds low until you realize one false positive per 50 candidates means you're flagging nervous people who write clean code while missing sophisticated cheaters who deliberately introduce typos. Gaze-tracking detection has significant blind spots for non-native English speakers, neurodivergent candidates, and anyone with a low-quality webcam. You need 720p at 30fps minimum for reliable tracking. Most laptop cameras in a dimly lit apartment don't qualify.

Here's what actually catches people, and it isn't an algorithm:

"What actually catches candidates isn't an algorithm; it's one follow-up question they can't answer." When a candidate regurgitates an AI response but can't defend it with specifics, the gap becomes obvious because AI answers are often more sophisticated than the candidate's ability to explain them.

That single insight explains the entire format shift. If the only reliable detection is a live human asking "why did you choose that approach?", then the format needs a live human in the room. Which brings us to what's replacing the take-home.

The Format Winning in 2026: Live AI-Allowed Pair Programming

Meta launched AI-enabled coding interviews in October 2025: a 60-minute format replacing one of two onsite coding rounds, with Claude and GPT available in a CoderPad environment. This is rolling out across all backend and ops roles in 2026. Google piloted "code comprehension" rounds where candidates debug existing code with Gemini as an assistant. Shopify, Canva, Rippling, Red Hat, and Uber all explicitly allow AI during live coding.

The design principle is elegant: present problems that can't be solved with a single prompt. They require iterative thinking, requirement clarification, and decision-making under ambiguity. The interviewer isn't watching whether you can code. They're watching whether you can think.

Meta's internal framing says it plainly: "This is more representative of the developer environment that our future employees will work in, and also makes LLM-based cheating less effective." When AI is allowed, hiding it isn't an advantage. Using it well is.

The sweet spot is 60-90 minutes total, with a 45-minute working window. Below 45 minutes, complex problems can't be evaluated. Above 90 minutes, senior candidates fatigue. That's a massive improvement over the 10-20 hour take-home, and it yields better signal because you're watching the candidate's actual reasoning in real time.

For data engineers specifically, these sessions are pulling from real production problems. Here's the kind of thing you might see:

-- You're handed this query that's timing out in production.
-- The interviewer asks: "Why is this slow? Fix it."
SELECT
    o.order_id,
    o.created_at,
    c.customer_name,
    p.product_name,
    SUM(oi.quantity * oi.unit_price) AS line_total
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id
JOIN customers c ON o.customer_id = c.customer_id
JOIN products p ON oi.product_id = p.product_id
WHERE o.created_at >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY o.order_id, o.created_at, c.customer_name, p.product_name
ORDER BY o.created_at DESC;

Then the interviewer pivots: "The schema just changed. The order_items table now has 800M rows and it's partitioned by month. Refactor." That pivot is what kills the overlay tools. Cluely can't regenerate a coherent architectural answer fast enough when requirements shift mid-question. A human who understands query optimization and window functions can.

What Interviewers Actually Watch For Now

The signal has shifted from code output to three observable behaviors: problem decomposition, AI skepticism, and output verification.

Problem Decomposition

68% of hiring leaders cite hands-on skill demonstrations and real-time problem solving as the most trusted talent indicators, above behavioral questions and resume credentials. In live sessions, the planning phase takes up more than half the total time. Candidates who jump straight to code signal that they haven't decomposed the problem.

For DE roles, this means breaking down pipeline puzzles before proposing architecture. "What stakeholders need this data?" and "What's the smallest useful deliverable?" are the questions that signal maturity. Not "let me write a DAG."

AI Skepticism

When an AI agent suggests a Spark optimization or a BigQuery partitioning strategy, the interviewer watches whether you read it, trace through it, spot edge cases (data skew, incorrect nullable logic, missing idempotency), and push back. The fastest rejection in 2026 is accepting a plausible-but-wrong suggestion without reading it.

Here's what that looks like in practice. Say the AI suggests this for deduplication:

-- AI-generated: "deduplicate events by user_id"
SELECT DISTINCT user_id, event_type, event_timestamp
FROM raw_events
WHERE event_date = CURRENT_DATE;

A candidate who ships that gets dinged. A candidate who says "hold on, DISTINCT across all three columns won't actually deduplicate if the same user fires the same event type at different timestamps; we need a CTE with ROW_NUMBER partitioned by user_id and event_type, ordered by timestamp, keeping only the latest" is demonstrating exactly the judgment interviewers want:

-- Corrected: proper deduplication with explicit grain
WITH ranked AS (
    SELECT
        user_id,
        event_type,
        event_timestamp,
        ROW_NUMBER() OVER (
            PARTITION BY user_id, event_type
            ORDER BY event_timestamp DESC
        ) AS rn
    FROM raw_events
    WHERE event_date = CURRENT_DATE
)
SELECT user_id, event_type, event_timestamp
FROM ranked
WHERE rn = 1;

Output Verification

In a live session, saying "Claude suggested this but it's wrong because..." carries more signal than shipping solo AI output. Companies like Google and Meta now evaluate prompt engineering, output validation, and debugging of AI-generated code as core competencies. The headline signal is judgment: the ability to direct, supervise, and verify an AI agent toward output that's actually ready for production.

Leading firms have even shifted from "build from scratch" to "fix AI-broken code." They hand candidates a repo of bugs and ask them to repair rather than architect. This inverts the incentive entirely: AI co-pilots can generate solutions but struggle to debug existing failures. That's the actual job, by the way. Less "write a DAG" and more "figure out why this pipeline silently dropped 2M rows last Tuesday."

Which Companies Already Ditched Take-Homes

The split is real and it's messy. 62% of organizations still prohibit AI use in interviews. But 67% of startups already allow AI, creating a two-tiered landscape where startup hiring moves faster and FAANG companies remain stuck in transition.

Roughly 75% of companies have eliminated take-homes or made them optional. The remaining 25% that still run 2-8 hour take-homes are increasingly adding mandatory live code walkthroughs afterward, where candidates explain their prompts, decisions, and corrections. That's basically a pair programming session with extra steps.

Companies explicitly allowing AI during live coding: Meta, Shopify, Canva, Rippling, Red Hat, Uber. Google piloted code comprehension rounds with Gemini. Amazon still leans toward banning AI entirely. This policy divergence means your next interview loop could go either way, sometimes within the same company across different teams.

For data engineering specifically, the companies that moved fastest are the ones building AI-integrated data platforms. They realized the absurdity of banning the tools their employees use eight hours a day. If your production environment includes Copilot for dbt model generation and Claude for pipeline debugging, testing candidates without those tools is testing the wrong thing.

How to Prep When the Format Is Mid-Transition

You're interviewing into a format that's actively changing. Your next company might ban AI entirely, allow it in parts, or require it. Here's how to not get caught flat-footed.

SQL fluency is still the highest-leverage prep. Joins, window functions, CTEs, aggregations, deduplication, query tuning. These carry across every format: take-home, live coding, pair programming, whiteboard. The format changes; the SQL doesn't. If you're weak on any of those, drill them until they're automatic.

Practice live debugging, not just building. As companies migrate to pair programming, interviews increasingly test incremental refinement rather than architecture from scratch. You'll be handed a schema or pipeline with one bug, and the round tests how fast you iterate. Practice reading EXPLAIN plans, rewriting queries for performance, and identifying cost-driving joins. The complete interview prep guide covers the full spectrum of what you'll face.

Learn to narrate your thinking. In a pair session, the interviewer is evaluating how you decompose problems, where you push back on AI suggestions, and how you verify output. Practice solving problems out loud. Say "I'm starting with the grain of this table because..." not just typing in silence. 60-90 minutes of reasoning out loud is how senior DEs actually work; take-homes hide this entirely.

Get comfortable using AI transparently. If the interview allows AI, the most successful candidates use it strategically for well-defined subtasks while maintaining control of the overall solution. They don't prompt and accept whatever it generates. They prompt, read, question, correct, and explain why. That meta-skill, knowing when to trust the AI and when to override it, is now a first-class interview signal.

Push back on scope. If a company sends you a 15-hour take-home in 2026, you're within your rights to ask for a 90-minute pairing session instead, or at minimum, compensation. The candidates they're losing to competing offers are the ones who refuse to do free consulting. Don't be the one who spends a weekend on a submission that gets ghosted.

The Format Is Broken. The Skills Aren't.

Here's what I keep coming back to: 71% of engineering leaders say AI has made technical skills harder to assess. But harder to assess doesn't mean less valuable. Data modeling, pipeline architecture, schema design, query optimization: these skills compound regardless of whether you demonstrate them in a take-home, a live session, or a pair programming round. The interview format is the wrapper. The concepts are the product.

The companies that figure this out fastest will hire the best engineers. The ones still running 20-hour take-homes with AI bans they can't enforce will keep losing top candidates to competitors who respect their time. And the engineers who invest in fundamentals deep enough to perform in any format, live, async, AI-allowed, AI-banned, will land regardless of which direction the industry lurches next.

The take-home is collapsing. The skills it was supposed to measure aren't going anywhere. Focus on those.