Developers are constantly looking for ways to improve their applications, automate repetitive tasks, and create better solutions. With artificial intelligence making software development faster and more accessible, it has become easier than ever to turn an idea into a working application. However, having the ability to build something does not always mean we should build it.
Sometimes, the most effective solution is also the simplest.
In this week’s episode of Building Better Developers, hosts Rob Broadhead and Michael Meloche reflect on their conversation with Ari Kimmelfeld, founder of Commonplace. Ari’s journey from a simple website selling used Peloton equipment to a nationwide secondhand marketplace provides an important lesson for developers and entrepreneurs: success often comes from identifying one meaningful problem and solving it well before expanding into something larger.
This week’s challenge focuses on the KISS principle—Keep It Simple. Instead of building another complicated application or attempting to automate an entire business process, we challenge you to identify one recurring problem, simplify it, and implement a practical solution.
This Week in Review: Building Something Simple That Works
Earlier this week, we spoke with Ari Kimmelfeld about his experience building Commonplace, a marketplace that makes buying and selling large secondhand products easier. Unlike traditional online marketplaces, Commonplace manages much of the complicated work surrounding a transaction, including inspections, pickup, delivery, and installation.
What makes Ari’s journey particularly interesting is how simply the business began.
His original website, TradeMySpin, focused exclusively on buying and selling used Peloton exercise bikes. Rather than creating a large marketplace with dozens of categories and complicated features, the website offered two straightforward choices: buy a Peloton or sell a Peloton.
That was enough to begin validating the business.
As demand increased, Ari expanded into additional categories and developed the technology and logistics necessary to support them. Today, Commonplace coordinates a network of delivery professionals, specialized inspections, payment processing, and other services that make purchasing expensive secondhand items more convenient.
The business became complicated because its customers’ problems required more sophisticated solutions, not because Ari tried to build every possible feature from the beginning.
For developers, this is an important distinction. We often begin projects by imagining everything an application might eventually do. However, starting with too many requirements can introduce unnecessary complexity before we understand whether the core solution is valuable.
AI Makes Building Easier, but Choosing What to Build Matters More
During the second part of our interview, Ari discussed how artificial intelligence has accelerated Commonplace’s ability to develop new functionality and experiment with business ideas.
Tasks that previously required larger development teams can now be completed much faster. This creates opportunities to test ideas that might once have been too expensive or time-consuming to pursue.
However, faster development introduces an interesting problem: when almost anything becomes possible to build, deciding what deserves your attention becomes increasingly difficult.
Michael points out that AI can create so many possibilities that developers and entrepreneurs become distracted by their own ideas. Instead of completing one meaningful improvement, they may find themselves pursuing several different features, applications, or automation projects without finishing any of them.
Rob reinforces the importance of starting with a small, self-contained solution. Whether building an application, improving an existing workflow, or launching a business, developers do not need to solve every problem at once.
The ability to generate additional code should not become an excuse to introduce unnecessary complexity.
Why Simple Solutions Are Often More Effective
One of the recurring themes throughout this week’s conversations is that simplicity makes it easier for people to understand and use a product.
Ari’s original two-button website worked because visitors immediately understood what they could do. There were no complicated menus, unnecessary options, or elaborate processes standing between customers and their goals.
Michael connects this idea to the problem of overwhelming customers with choices. When people are presented with too many options, making a decision becomes more difficult. The same principle applies to software design.
An application with numerous screens, buttons, and configuration options may appear powerful, but that complexity can also make it frustrating to use.
Rob suggests approaching development with the goal of reducing an application to the smallest number of moving parts possible. Ideally, a simple solution might consist of one page, one form, or one button that performs a useful task.
This does not mean every application can or should remain that small. Instead, the goal is to begin with the simplest version that accomplishes the desired outcome and expand only when additional functionality becomes necessary.
For developers, simplicity is not a limitation. It is a design decision that encourages clarity, usability, and maintainability.
The Weekly Challenge: Solve One Problem and Automate It
This week’s challenge is straightforward: identify one problem you experience regularly and create the simplest possible solution to address it.
The problem does not need to be complicated or technically impressive. In fact, choosing something small is the point of the exercise.
Perhaps you spend several minutes every morning organizing files, manually copying information between applications, or reviewing the same information across multiple systems. Maybe you repeatedly perform a task that could be simplified with a small script, automated reminder, or basic application.
Instead of planning a complete system to automate your entire workflow, focus on removing one specific frustration.
Your Challenge for This Week
- Identify one recurring problem. Choose something you encounter frequently that wastes time, creates confusion, or requires unnecessary manual effort.
- Define the simplest possible outcome. Determine what success looks like without adding features that are not necessary to solve the immediate problem.
- Use AI to simplify your approach. Ask an AI assistant to help identify the minimum steps required to solve the problem. Challenge it to reduce complexity rather than suggest additional functionality.
- Build or automate one solution. Create a small script, workflow, form, or application that addresses the problem. Keep the implementation as focused as possible.
- Test the result and improve it. Use your solution in a real situation and determine whether it actually makes your work easier. Make adjustments based on what you learn rather than expanding the scope unnecessarily.
The objective is not to create a perfect application. It is to finish something useful.
Using AI to Simplify Instead of Complicate
One suggestion Rob offers during the discussion is to use AI specifically as a tool for reducing complexity.
Many developers approach AI by asking it to generate applications, add features, or recommend improvements. While these capabilities are valuable, they can also encourage unnecessary development.
Try approaching AI from the opposite direction.
Describe the problem you want to solve and ask what can be eliminated from the proposed solution. If you are building an interface, ask whether the number of screens or buttons can be reduced. If you are automating a process, ask whether fewer steps could accomplish the same result.
For example, rather than requesting an entire document management application, consider whether a simple script that organizes files into folders would solve your immediate problem.
Instead of creating a sophisticated dashboard for every business metric, determine whether a small report containing three meaningful measurements would provide the information you actually need.
The goal is to use AI to help you think more clearly about the problem, not simply to produce more code.
Building Better Developers: Start Small and Keep Moving Forward
As we wrap up this week’s conversations, the biggest lesson from Ari’s experience is that meaningful progress does not require starting with something complicated.
Commonplace grew because Ari identified a specific problem, created a simple solution, and continued improving it as customers revealed new needs. Some experiments succeeded, others failed, and each experience helped shape the business.
That approach applies equally well to software development, career growth, and entrepreneurship.
You do not need to build the next major marketplace or develop a revolutionary application to become a better developer. Sometimes, solving one frustrating problem in your daily routine can provide a better learning experience than starting another ambitious project.
This week, resist the temptation to build everything. Choose one problem, find one practical solution, and use AI to help make that solution as simple as possible.
Once you have something that works, you can decide what comes next.
Remember, becoming a better developer is not about how much code you write. It is about the problems you solve and the value you create.
Keep it simple, keep learning, and keep building better solutions.
Stay Connected: Join the Developreneur Community
👉 Subscribe to Building Better Developers for more conversations on momentum, leadership, and growth. Whether you’re a seasoned developer or just starting, there’s always room to learn and grow together. Contact us at [email protected] with your questions, feedback, or suggestions for future episodes. Together, let’s continue exploring the exciting world of software development.