👋 Ciao, Alex here. Welcome to a new free edition of Not Just Bits. Thank you to all the readers and supporters of my work! Every month, I aim to share lightweight and informative resources for CTOs.
For years, product discovery has been seen as a PM and designer-driven process, with developers involved but consistently deprioritizing it in favor of delivery. However, in modern product development, waiting for final specs is outdated. Developers should be actively engaged in shaping what gets built—not just how it gets built.
This is where Continuous Discovery comes in. By integrating engineering insights early, teams can validate assumptions faster, reduce waste, and create products that are both valuable and scalable.
Why Developers Should Be Actively Involved in Discovery
Discovery isn't just about finding the right user problem; it's also about finding the right technical approach. Developers can proactively contribute to discovery in several ways.
1. Build for Tech Wealth, Not Just Features
In the world of Continuous Discovery, developers aren’t just executors—they’re strategic partners who help shape what gets built and how it evolves. A crucial part of this responsibility is balancing Tech Wealth vs. Tech Debt.
Instead of accumulating Tech Debt that slows progress and turns into a never-ending backlog, Tech Wealth is about being proactive. Minimizing Tech Debt doesn’t mean avoiding it entirely, it means managing it wisely.
Too often, teams treat Tech Debt as just another backlog item, continuously pushing it forward rather than addressing it in ways that lead to better long-term solutions.
This doesn’t mean overengineering—software development isn’t a binary choice. It’s about finding the right balance between speed and sustainability
2. Prototype to Test Feasibility Early (with AI & Automation)
Product teams often rely on mockups and user tests, but developers can go one step further with rapid technical prototyping. AI and automation tools are making this process even more efficient:
🤖 Use Cline – an AI coding agent that builds software components, APIs, and entire features based on high-level prompts. Instead of manually prototyping an idea, developers can describe the logic, and Cline will generate working code. This enables rapid iteration and validation before investing time in full development.
🤖 Leverage Claude (Anthropic’s AI assistant) – for rapid code scaffolding—it can generate proof-of-concept APIs, script automation, and even suggest optimizations before full development.
Suggest low-cost MVPs instead of overengineering a full solution.
Use feature flags or A/B testing to test features in a live environment.
With AI-driven tools like Cline and Claude, teams can prototype faster, reducing uncertainty and accelerating the discovery process.
3. Challenge Assumptions with Data
Developers often have access to backend analytics, logs, and performance metrics that reveal hidden user behaviors. They should use this data to challenge product decisions:
Do we really need this new feature, or can we improve an existing one?
Can we solve this problem with automation or better defaults?
Are we measuring the right success metrics, or are we optimizing for the wrong thing?
One way developers can actively contribute to data-informed discovery is by leveraging Metabase, a powerful open-source BI tool that allows teams to explore and visualize product data minimal effort.
4. Join Discovery Conversations
Developers shouldn't just wait for specs—they should be actively involved when problems are being discussed. Some ways to get involved:
Attend customer interviews to hear pain points firsthand. Tools like Chattermill can help analyze customer feedback at scale, making it easier to identify recurring issues.
Co-design solutions with PMs and designers.
Offer technical perspectives on what’s viable and scalable.
By participating early, engineers can shape the problem space rather than just receiving the solution.
5. Think in Systems, Not Just Features
Many product ideas focus on short-term feature delivery, but great engineers look at long-term system impact:
How does this feature fit into our tech roadmap?
Are we creating a fragmented experience by adding this?
Will this add operational costs or tech complexity we’ll regret later?
Bringing a systems-thinking approach to discovery helps avoid unnecessary complexity and improves long-term product stability.
Takeaways
Developers who are actively involved in discovery don’t just build features—they shape better products. By prioritizing Tech Wealth, rapid prototyping (leveraging AI and automation), data-driven decisions, and cross-functional collaboration, developers can ensure their teams ship not just fast, but smart.
The best engineers don’t just write code—they help define what’s worth building in the first place.
✅ Before you go:
Please share this post and invite your network to subscribe to the Not Just Bits newsletter.
Feel free to connect with me on LinkedIn.
See you next month! Best, Alex Di Mango