When Anyone Can Build Software, Should I Still Build Software?
Why this is the beginning, and not the end of software craft
It used to take special skills to build good software. It still does, just a different mix.
At one point I was a "serious hobbiest" photographer. I had grown up in a house with a darkroom, made an early switch to digital, and have had an SLR for most of my life.
But the proliferation of photographs - orders and orders of magnitudes more than there had been just a decade before left me creatively paralyzed, overwhelmed by the sense that every possible image had already been captured countless times.
Then I came to realize that the jagged edge that defined photography as art, had changed. The next photo artist wouldn't produce novelty in the same way Ansel Adams had decades before. Instead, projects that made use of millions of photographs became interesting, like Photosynth from Microsoft Research:
Which eventually was used in Microsoft Flight Simulator to create buildings and terrain across the entire world.
I even started a company at this jagged edge— Art Moments let people turn their snapshots into artwork by printing them on watercolor paper and canvas (now a common offering from Shutterfly and others).
Entire forms of media, like Instagram, opened up and we found new ways to communicate with each other.
We're at the Photosynth moment for software.
And just as photography evolved from a specialized craft to a ubiquitous medium of expression, software development is undergoing a similar transformation.
Today, the barriers to creating software are dissolving. Tools that once required deep technical expertise now welcome newcomers with intuitive interfaces and assistive capabilities. The proliferation of AI code generation assistants, and large language models has democratized creation in ways unimaginable just a few years ago.
But this doesn't mean the end of craft—rather, it signals a shift in what we value. Just as the photographer's eye became more crucial than darkroom techniques, today's software creators are valued for their vision, problem-solving abilities, and human-centered design thinking over syntax mastery.
The most interesting software emerging today isn't distinguished merely by its technical implementation but by how deeply it understands human needs and contexts. The new literacy isn't just writing code—it's writing code that matters.
Some lament this change, just as photographers once mourned the loss of exclusivity. But I've come to see it differently. When millions can build, the question becomes not "Can you make software?" but "What will you make, and why does it matter?"
This democratization opens doors to voices previously excluded from the conversation. People with domain expertise but without traditional coding backgrounds can now build solutions to problems they intimately understand. Healthcare workers creating patient management systems. Teachers developing custom learning tools. Community organizers building platforms for collective action.
The future belongs not to those who can write the most elegant algorithms, but to those who can imagine new possibilities at the intersection of human needs and technological capabilities.
So rather than feeling sad or unmotivated by this sea change, I've found renewed purpose. Just as photography evolved into new art forms and communication channels, software development is becoming something richer, more diverse, and potentially more meaningful than before.
The skills that matter now are empathy, systems thinking, ethical reasoning, and creative problem-solving. Technical knowledge remains important, but as a means rather than an end.
Empathy: Consider the story of Ava, who built an app to help seniors manage medications. Her first version, though technically flawless, confused its target users. Rather than blaming "user error," she spent a week observing her grandmother navigate the interface. She discovered assumptions she'd made about comfort with technology that simply weren't true. The redesigned app eliminated technical jargon, increased touch targets, and incorporated familiar physical metaphors like a pill box. Usage soared not because Ava wrote better code, but because she stepped outside her own perspective.
Systems thinking: Take Marco, who was tasked with creating yet another customer management portal. Instead of building everything from scratch, he mapped the ecosystem of available tools and services. He orchestrated APIs from existing payment processors, integrated an open-source analytics platform, and leveraged authentication services rather than reinventing them. The result wasn't just a CRUD app, but an interconnected system that shared data across previously siloed departments. Marco's value wasn't in writing every line of code, but in understanding how pieces could work together to create something greater than the sum of its parts.
Ethical reasoning: When Priya's team built an AI-powered hiring tool for a large corporation, initial tests showed it favored candidates from prestigious universities and those with traditionally male names in technical roles. Rather than deploying what seemed "objectively" effective, Priya insisted on examining these patterns. She advocated for rethinking what metrics constituted a "good" employee and diversifying the training data. The revised system identified candidates who had been historically overlooked yet performed excellently. The most valuable line of code Priya wrote wasn't an algorithm—it was a question about who their system might be leaving behind.
Problem-solving: Jamal was developing software for a hospital when he noticed nurses spending hours manually entering data from one system to another. The conventional approach would have been to automate this specific task. But by asking "why does this transfer need to happen at all?" Jamal discovered two systems that should have been talking to each other but weren't. Rather than coding a sophisticated transfer tool, he created a simple integration between existing systems. The solution required relatively little code but saved thousands of hours and reduced errors. The most important problem he solved wasn't at the code level, but at the workflow level.
We're just beginning to see what this new era might bring. My vision for this future is both practical and transformative:
Interfaces will feel intuitive not because they follow universal design principles, but because they're created by the very people who use them daily
Software will become ephemeral and situational—like snapshots, applications can serve their purpose for a moment without needing to be preserved in a digital museum
Complex systems will emerge through composition, as we build increasingly sophisticated solutions atop existing technologies rather than starting from scratch
Hyper-personalized software will proliferate, with applications tailored not just to demographic segments but to individuals and specific communities
We'll witness the rise of software ecosystems where millions of specialized applications can seamlessly work together, creating capabilities greater than any single platform
How to Adapt Now
So how do you navigate this shift? How do you ensure you're riding this wave rather than being swept under by it?
Embrace the disposable nature of code. Your work isn't precious—it's a means to an end. The artifact that matters is the solution, not the implementation. This mindset frees you to create multiple rapid prototypes, test hypotheses quickly, and pivot without emotional attachment to what you've built.
Learn to build, regardless of your background. There's no longer an excuse to be merely a consumer of technology. Even if you never intend to code professionally, understanding how to create simple tools gives you agency in a software-mediated world. Start small—automate a repetitive task, build a simple app to solve your own problem.
Practice just-in-time skill acquisition. Focus on making things you care about, and learn what you need as you go. The person who attempts to master everything before creating anything will be perpetually preparing. Instead, set ambitious goals and let necessity guide your learning path.
Like photography before it, software is becoming a medium through which we understand and reshape our world—not just a technical discipline, but a form of expression, connection, and transformation available to all.
The future is being written in more voices than ever before. Make sure yours is among them.