Why Every Developer Lies — And AI Will Not Fix That
By: Evgeny Padezhnov
Every developer lies. About estimates, about understanding the codebase, about whether the test actually passed locally. The lies are rarely malicious. They are survival tactics in a profession that punishes uncertainty.
AI coding assistants promised to remove the pressure. They did not. They moved the lies one layer deeper, into commit messages, PR descriptions, and self-reported productivity metrics.
The Four Lies Every Developer Tells
The first lie: "It will take two days." Practice shows the real answer is usually four to six. Developers compress estimates because the room expects confidence, not range.
The second lie: "Yes, I know that library." The honest version is "I read the README twice and skimmed the API." Admitting otherwise feels like volunteering for the imposter label.
The third lie: "The tests pass on my machine." Sometimes they pass because of cached state, an environment variable set six months ago, or a service running on localhost:5432 that nobody documented.
The fourth lie: "I understood the requirements." Often the requirements were ambiguous, and asking again felt like admitting the previous meeting was wasted.
Key point: These are not character flaws. They are responses to environments where uncertainty is treated as incompetence.
Imposter Syndrome Is The Engine
The article Living with Imposter Syndrome as a Software Developer notes that imposter syndrome manifests as fear that everyone else is more competent. It affects developers worldwide and produces reduced productivity, poor work ethic, and low self-esteem.
The same article mentions one pull request that required around 10 revisions. That is not unusual. That is Tuesday.
A study by Clayton Lewis cited in Imposter Syndrome in the Software Development Field found that 77% of computer science faculty members disagreed with the idea that almost everyone can succeed in CS with sufficient effort. The people teaching the field believe most students will not make it. The students absorb that signal.
The result is a culture where developers under-report difficulty. They claim familiarity they do not have. They estimate based on what the lead wants to hear, not on the code.
Common mistake: Treating imposter syndrome as something individuals fix alone. It is structural. It comes from environments that reward false certainty.
Learned Helplessness In Risk-Averse Teams
The Leadership Garden article on epistemic learned helplessness describes engineers in financial institutions who become extremely risk-averse. They stick to well-established technologies even when newer ones exist. Fear of failure traps them in a cycle of avoiding change.
That pattern produces a specific kind of lie. The developer says "this is the standard approach" when the real meaning is "this is the only approach that will not get me blamed if it breaks."
The lie is technically true. The standard approach is the standard. The omission is that better approaches exist and were not considered because the cost of advocating for them is too high.
In plain terms: Risk-averse environments do not produce honest engineering. They produce defensible engineering.
Why Live Planning Meetings Make Lying Worse
Live estimation rituals — sprint planning, refinement, stand-ups — compress decision time. A developer is asked for a number with twelve colleagues watching. The social cost of saying "I do not know" rises with audience size.
Asynchronous estimation produces different numbers. A developer writing an estimate in a document at 10 PM is not performing. The estimate tends to be larger and closer to the actual outcome.
The fix is not abolishing meetings. The fix is separating the moment of estimation from the moment of commitment. Estimates written privately first, then discussed, then revised.
Try it: Next sprint planning, ask everyone to type their estimate in a shared document before anyone speaks. Compare to the verbal estimates the team would have given. The gap is the lie tax.
Psychological Safety Is The Counterforce
Research summarized in Engineering Manager Tools on psychological safety identifies it as the top predictor of team performance. Teams with safety detect problems earlier and communicate honestly. Teams without it stay silent while problems compound.
The same source advises managers to share the reasoning behind decisions, including the uncertainties and trade-offs involved. When the team sees the manager making decisions under uncertainty, they feel less pressure to appear infallible themselves.
Novoda's guide recommends a stronger move. Leaders should acknowledge and celebrate their own failures by saying "I messed up. This didn't go well." That sentence resets the floor of what is acceptable to admit.
The Platform Engineering source notes that Gallup data shows letting employees know their opinion counts reduces turnover and boosts productivity. Honesty is not just an ethical good. It is a retention strategy.
Tested in production: Teams that hold weekly retrospectives where the lead speaks first about their own mistakes report measurably more bug-finding in code review. The mechanism is simple. If the senior person can be wrong, the junior person can ask the question.
AI Did Not Fix Honesty. It Made The Lies Faster.
The promise of AI assistants was that uncertainty would drop. Developers would understand their code better, ship faster, and have less reason to fake confidence. The reality is messier.
Three new lies emerged.
The first new lie: "I reviewed the AI's output." Often the developer skimmed it, ran it, and pasted it. The output works, so the lie holds — until a subtle bug surfaces six weeks later.
The second new lie: "I wrote that function." Authorship is now ambiguous. Some teams require disclosure. Most do not. The ambiguity creates a pressure to claim full ownership of code the developer cannot fully explain.
The third new lie: "AI made me 40% more productive." Productivity claims based on lines of code, commits, or completed tickets inflate easily with AI assistance. The metric goes up. Whether the work delivers value is a separate question.
Common mistake: Measuring AI productivity by output volume. Lines of code produced is not a signal of value. It is a signal of activity.
A more honest measurement is defect rate, time-to-resolution for production incidents, and the percentage of PRs that ship without a follow-up fix. Those numbers are harder to game with AI assistance.
The Real Cost Of Estimate Lies
The Simple Thread article on unnecessary anxiety describes the constant churn of technologies and the impossibility of mastering more than a small sliver of the field. Estimates promised in that environment are uncertain by construction.
When developers compress those estimates to meet expectations, three costs follow.
First, deadlines slip. The two-day estimate becomes a five-day reality. The team replans, stakeholders lose trust, and the next estimate gets compressed even more.
Second, quality drops. Compressed timelines push developers to skip tests, skip documentation, and ship features with known rough edges. The technical debt compounds.
Third, burnout accelerates. The Platform Engineering source notes that delivering fast at all costs burns people out. Compressed estimates are the daily expression of that pressure.
If it works — it is correct. But the reverse holds too. If the team is burning out, the process is not working, regardless of the velocity charts.
What Actually Works
Honesty is a system property, not an individual virtue. Four practices shift the system.
Separate estimation from commitment
Write estimates privately first. Discuss the range. Commit to the upper bound, not the median. The team that commits to four days for a two-to-four-day task ships on time more often than the team that commits to the average.
Make "I do not know" a normal answer
In stand-ups, code review, and planning, the senior people should model the phrase. "I am not sure how this interacts with the auth service" is a stronger contribution than a confident guess.
Measure what matters
Replace velocity and lines-of-code metrics with defect escape rate, mean time to recovery, and PR rework percentage. These numbers resist AI inflation. They reward honesty in the development process.
Use AI as a tool, not a witness
When AI generates code, the developer still owns understanding it. A useful rule: the developer should be able to explain every line in code review without referring to the AI prompt. If they cannot, the code is not ready.
Key point: AI is a productivity amplifier for engineers who already work honestly. It is a lie amplifier for engineers under pressure to perform certainty.
What To Try Right Now
Pick one estimate currently on the team's board. Open it in a private document. Write the honest range, not the committed number. Compare them. If the gap is more than 30%, the team has an honesty problem, not an estimation problem.
The fix is not better estimates. The fix is an environment where the honest number is the acceptable number.
Frequently Asked Questions
Does estimate lying happen differently in remote versus in-office teams?
Remote teams that rely on async communication tend to produce more accurate estimates. Written estimates allow time for reflection. In-office teams with verbal stand-ups face higher social pressure to compress numbers in real time. Neither format fixes the underlying culture, but async reduces the performance tax.
Why is it easier to be honest about estimates in async communication than in live planning meetings?
Live meetings compress decision time and add audience pressure. A developer types differently than they speak when twelve colleagues are watching. Async removes the performance element. The estimate becomes a thought, not a public commitment under observation.
Is what we call "developer lies" actually just scope mismatch between teams?
Often, yes. The developer estimates the code. Product estimates the feature. Stakeholders hear a number and assume it includes testing, deployment, and rollback. The lie is partly a translation failure across roles. Explicit scope definition before estimating reduces the gap significantly.
How can teams measure AI productivity without inflating metrics?
Track defect escape rate, time to recovery from production incidents, and the percentage of PRs that ship without follow-up fixes. Lines of code and commits per day are easy to inflate with AI. Outcome metrics are not. If the team genuinely ships faster with fewer regressions, AI is helping. If only the activity metrics rise, it is not.
Why do developers say things they know are wrong in the moment they are saying them?
The cost of the lie in the moment is lower than the cost of admitting uncertainty in front of peers and managers. Imposter syndrome, learned helplessness, and risk-averse cultures all push toward false certainty. The lie is a short-term coping mechanism with long-term costs the developer will pay later.
Information is accurate as of the publication date. Terms, prices, and regulations may change — verify with relevant professionals.