As artificial intelligence reshapes software development, a common refrain has emerged: LLMs may be capable at writing code, but “coding is easy—figuring out what to code is the hard part.” According to a blog post by Senko, this framing is “a gross insult to all programmers everywhere.”
The author argues that if coding were truly easy, several industry realities wouldn’t exist. Programmers have commanded high salaries for years, experienced significant stress and burnout, and companies have invested heavily in identifying top talent through rigorous technical interviews. Canonical texts like Clean Code, The Pragmatic Programmer, and The Art of Computer Programming would be unnecessary if the work were straightforward. Bootcamps and college degree programs dedicated to programming also suggest the discipline requires genuine skill and knowledge.
The post further contends that the alternative claim—that understanding customer needs and determining what to build is harder—also doesn’t withstand scrutiny. Product managers, market researchers, and business analysts are not treated as rockstars in most software companies, nor are they compensated at developer rates, despite supposedly tackling the “harder” problem. The author notes that if discovering demand were the real challenge, programmers would embrace salespeople closing deals based on promised features.
The author acknowledges a prevailing sentiment that most software work involves stakeholder communication and requirements clarification, but observes that many developers actively avoid these tasks. However, few developers excel equally at both coding craftsmanship and deep customer empathy—most lean heavily toward one.
Despite these critiques, the author emphasizes that both understanding the system being built and understanding why it’s being built matter. Rather than dismissing code as trivial or defending it as irreplaceable art, developers should recognize the industry is undergoing fundamental change and adapt accordingly.
The post identifies what likely won’t change: software complexity will grow, maintenance needs persist, users will want more for less, and they’ll struggle to articulate their actual needs. However, programming languages, tools, and techniques have continuously evolved—developers once labored with C memory management and SQL injection vulnerabilities that are now largely obsolete.
The author recommends embracing curiosity about new technologies while maintaining critical judgment about hype. Senior developers should broaden their knowledge of user experience and business strategy. Junior developers should deepen their understanding of fundamentals like pointers, recursion, and algorithms, even if working in high-level languages.
Key facts
- The blog post argues that claiming ‘coding is easy’ contradicts decades of high programmer salaries, demand for talent, and industry resources devoted to teaching the skill
- The author contends that if understanding customer needs were truly harder than coding, product managers and business analysts would be paid more and treated as top talent
- The post acknowledges change in the industry but argues that maintaining software, handling complexity, and understanding user needs will always require skilled work
- The author recommends developers balance learning new tools and AI capabilities with deepening expertise in fundamentals and adjacent fields like customer empathy and business strategy