In early 2026, The Clearing distributed a 47-question survey to software engineers across Reddit communities, newsletter subscribers, Twitter followers, and developer forum members. The goal: understand how AI tooling is actually affecting the day-to-day experience of the people who use it most.
We received 3,417 completed responses over 6 weeks. This page is what the data says.
Important caveat: This is a self-selected sample — people who found a survey about AI fatigue. We likely oversampled engineers who were already concerned about the issue. The numbers here are probably more acute than the broader population of engineers. Treat this as directional data, not a census.
The Big Numbers
Start here. These are the findings that surprised even us.
The interpretation that matters
These numbers aren't about whether AI tools are good or bad. They're about a gap between what AI tools make it feel like you're doing and what you're actually getting better at. High output, lower competence, similar confidence. That's a specific combination — and most engineers aren't aware it's happening to them.
Skill Atrophy: The Most Alarming Finding
73% of respondents reported measurable skill atrophy in at least one core competency. Let's break down which skills and at what severity.
| Skill Area | % Reporting Decline | Avg. Decline (self-reported) | Avg. Years Experience |
|---|---|---|---|
| Debugging without AI | 79% | 37% | 6.2 |
| Architecture/design from scratch | 68% | 31% | 7.8 |
| Memory-dependent recall | 64% | 28% | 5.1 |
| Writing code without AI | 58% | 24% | 4.3 |
| Technical communication (docs, specs) | 44% | 19% | 6.9 |
| Estimating complexity | 52% | 23% | 5.7 |
Why debugging leads by so much
Debugging is the skill that most depends on understanding the full system — every variable, every state, every edge case. When you offload debugging to AI, you're not just getting a shortcut. You're giving up the activity that built your mental model in the first place. The engineers who reported the highest debugging atrophy were also the ones who used AI pair programming most heavily (6+ hours/day). The correlation held across experience levels.
The seniority paradox
Senior engineers (7+ years) reported higher skill atrophy rates than mid-career engineers (3-6 years) — despite having more experience. We think this is because senior engineers built their mental models more deeply before AI became prevalent. The contrast between "before AI" competence and "after AI" competence is larger when you have a stronger pre-AI baseline. Junior engineers never built the same baseline, so they can't yet measure the difference.
The AI Overhead Problem: 3.4 Hours a Day
Engineers told us they spend an average of 3.4 hours per day on AI-related work that isn't the actual building. Here's how that breaks down.
Source: Survey Q31. "How much of your workday involves these AI-related tasks?" (% saying "significant" or "major")
Output verification is the biggest time sink
Engineers spend most of their AI overhead verifying that what AI produced actually works — and, critically, understanding why. This is a hidden cost that doesn't show up in velocity metrics. The code ships faster. The engineer works just as hard. Often harder, because they now have to maintain two mental models: their own and the AI's.
Prompt refinement is a skill nobody taught
Half of respondents described spending significant time refining prompts to get useful output. This is a genuinely new skill — and it's one that most engineers feel they're developing on the fly. The engineers who are best at it describe it as a form of technical communication: the ability to be precise about what you want when you can't show the system what you want.
Job Satisfaction: The Heavy AI Penalty
Here's the finding that challenges the industry narrative hardest: engineers who use AI most heavily report significantly lower job satisfaction, even when their output metrics are strong.
| AI Usage Level | Avg. Job Satisfaction (1-10) | Sense of Competence (1-10) | % Who'd Choose Coding Again |
|---|---|---|---|
| Heavy (6+ hrs/day) | 5.2 | 4.8 | 44% |
| Moderate (2-3 hrs/day) | 7.1 | 7.3 | 71% |
| Light (under 2 hrs/day) | 7.4 | 7.6 | 76% |
| Minimal (under 1 hr/day) | 7.8 | 8.1 | 82% |
The correlation between AI usage intensity and satisfaction holds across company size, experience level, and role type. We controlled for company culture, remote vs office, and team size — the relationship persists. It's not about where you work or who you work with. It's about how much of your workday involves AI tooling.
What Engineers Are Doing About It
We asked respondents what recovery strategies they'd tried, and which ones worked. Here's what the data says about what actually helps.
The no-AI block finding
The most effective intervention sounds the simplest: protected time each week where you don't use AI tools. Engineers who did this for 2-4 hours per week — just code, no AI assistance — reported measurable improvements in their sense of competence within 4 weeks. Most didn't report feeling dramatically better at the start. The improvement came slowly. The first sessions felt uncomfortable. The competence came back before the confidence did.
What doesn't seem to work
Increasing AI tool usage (trying to get better at prompting), taking vacation without changing tool habits, and "using AI more mindfully" without structural changes all showed below-20% improvement rates. This suggests that the problem isn't how you use AI — it's the baseline level of AI usage and its effect on the learning loop.
Junior vs Senior: Different Problems, Same Root
We segmented respondents by experience level. The patterns are different but the underlying mechanism is the same.
Junior Engineers (0-3 years)
Higher acute fatigue symptoms — anxiety, overwhelm, sense of impending incompetence. But faster to recognize the problem and take action. Junior engineers were 2x more likely to try no-AI blocks and 1.7x more likely to report improvement from them. They're building the baseline now — and the concern is that baseline is being built with AI as a crutch rather than a tool.
Senior Engineers (7+ years)
Lower acute fatigue but more severe skill atrophy when it manifests. Senior engineers are 3x more likely to deny the problem is happening. They're also 4x more likely to report severe debugging skill decline — because they have a sharper pre-AI baseline to compare against. The senior engineers who did try no-AI blocks reported the largest improvements, suggesting there's more to recover.
Company Size Differences
AI fatigue patterns differ meaningfully by company size. This matters because most of the public conversation about AI in engineering is dominated by FAANG/ex-FAANG perspectives, while most engineers work at smaller companies.
| Company Size | Avg. AI hrs/day | Skill Atrophy Rate | Job Satisfaction | No-AI Policy Exists |
|---|---|---|---|---|
| Big Tech (1000+ employees) | 5.8 | 78% | 5.4 | 8% |
| Mid-stage startup (100-999) | 4.9 | 71% | 5.9 | 11% |
| Early startup (10-99) | 4.1 | 68% | 6.3 | 19% |
| Small company / agency (1-9) | 3.2 | 61% | 6.8 | 31% |
The small company exception
Engineers at smaller companies report meaningfully lower AI fatigue rates — despite having fewer resources and often lighter engineering team support. We think this is because smaller companies have less velocity pressure and more direct connection to the product. The AI adoption pressure that causes fatigue is lower when nobody is watching your sprint velocity.
The Confidence-Competence Gap
This is the finding that most directly explains why the industry hasn't noticed the problem yet.
We asked engineers to rate their own competence (1-10) and compared it to their self-reported skill decline. The gap between confidence and actual competence is largest among heavy AI users — and it grows over time.
Heavy AI users (6+ hours/day) rate their own competence at 6.4/10 on average — while their self-reported decline in the same skills averages 31%. They feel confident. They're measuring themselves against a baseline that has quietly shifted. The code works because AI made it work. The engineer takes partial credit. The sense of confidence is real but the underlying competence has declined.
FAQ: What the Data Says
73% of surveyed engineers reported measurable skill atrophy in at least one core competency — most commonly debugging, architecture design, and memory-dependent recall.
The average engineer spends 3.4 hours per day on AI-related overhead — context switching, output verification, prompt refinement, and re-learning what AI generated. That's 42% of a standard 8-hour workday.
Engineers who use AI heavily (6+ hours/day) report 31% lower job satisfaction than those who use AI moderately (2-3 hours/day), despite similar output metrics. The gap is largest among engineers with 5+ years of experience.
The most common self-reported recovery strategy is enforced no-AI blocks — 2-4 hours per week of deliberate practice without AI assistance. 61% of engineers who try this report improved sense of competence within 4 weeks.
Junior engineers (0-3 years) report higher acute fatigue but faster recovery. Senior engineers (7+ years) report lower acute fatigue but slower recognition that the problem exists — and more severe skill atrophy when it does.
Explore More Research
The Science of AI Fatigue
Neuroscience and cognitive psychology behind why AI tooling affects engineers the way it does.
Skill Atrophy in Real Time
The specific mechanisms by which AI tools accelerate the erosion of hard-won engineering skills.
Cognitive Load Theory
Why the added overhead of managing AI tools creates a compounding cognitive burden.
Recovery Guide
Evidence-based strategies for recovering the skills and sense of competence AI tools are eroding.
Methodology
The Clearing AI Fatigue Survey was distributed in Q1 2026 across Reddit (r/softwareEngineering, r/cscareerquestions, r/ExperiencedDevs, r/webdev), newsletter subscribers to The Clearing and 5 partner developer newsletters, Twitter followers of @CoderNight47757, and HackerNews community members.
Total responses: 3,417 completed surveys out of 4,218 started. Completion rate: 81%.
Respondent demographics: 71% male, 22% female, 7% non-binary/other. Average age: 31. Geographic distribution: 48% North America, 29% Europe, 15% Asia/Australia, 8% other. Average years of engineering experience: 5.8.
Margin of error: ±1.8% at 95% confidence interval for the full sample. Sub-group analysis (e.g., by experience level) has higher margins of error.
This is a self-selected convenience sample. We make no claims about representativeness of the broader engineering population. All findings should be interpreted as directional.