Vibe Coding and Test-driven Development

TDD

I've been playing around with various vibe-coding tools. While working on building this blog using Astro, I asked Claude Code to use a test-driven development (TDD) approach.

Bingo! It just built a whole test bed and followed the TDD approach for every new feature that's built.

I liked Bolt.dev, but since I started using Claude Code, it's a completely different experience. Bolt can still provide compelling prototypes. That, along with Claude Code, takes it to the next level with its much more intelligent implementation.

vibe-coding-tdd

I've also asked it to make it a practice without me reminding it of TDD every time. For that, Claude inserted the following into its config file:

Claude-Config

Eventually, I ended up with 90 tests and Claude executing them as I work on improving the functionality.

Be careful with overfitting

Apart from this, I had issues with rendering images on the homepage. It took me a couple of iterations to get it right with Claude. Sometimes, you see the model overfitting to your precise rules. Even to an extent, it hardcodes certain logic, in this case, the image file name. Being with it, nudging, and providing additional context usually fixes the issues.

So far, so good! I can clearly see where we are heading ... a world of exponential efficiencies from where we are.

Architect vs. Gardner: Product Development Mindsets

Product development demands vision and execution. But the mindset you bring to the work often shapes outcomes as much as strategy or process. Two powerful metaphors illustrate this tension: the Architect and the Gardener.

Both have value. Both can lead to success. But knowing when to adopt one mindset over the other—and how to balance them—can mean the difference between building structures that endure and nurturing products that adapt.

The Architect Mindset

Architects design with precision. They think in terms of structure, alignment, and long-term durability. In product development, the Architect mindset emphasizes:

  • Clear upfront planning: mapping requirements, dependencies, and milestones.
  • System-level thinking: ensuring coherence across design, engineering, and business goals.
  • Risk reduction: anticipating failure points and designing safeguards.
  • Stability and scalability: creating foundations that support future growth.

This mindset is critical when decisions are high-stakes and irreversible. Large-scale migrations, compliance-driven initiatives, or platform re-architecture require the rigor and foresight of an Architect.

The strength of the Architect lies in discipline. Teams guided by this mindset avoid costly rework, deliver predictable results, and ensure alignment across complex initiatives.

But the Architect has pitfalls. Excessive planning can paralyze. Overconfidence in design can ignore the uncertainty of markets or customers. Architect-dominated cultures risk rigidity, prioritizing structure over learning.

The Gardener Mindset

Gardeners nurture growth in environments they don’t fully control. They focus on conditions, experimentation, and adaptation. In product development, the Gardener mindset emphasizes:

  • Discovery over certainty: testing hypotheses with customers before committing to solutions.
  • Incremental progress: delivering small changes, observing impact, and iterating.
  • Adaptability: pruning ideas that don’t thrive and doubling down on those that do.
  • Empowerment: trusting teams closest to the problem to experiment and decide.

This mindset is most powerful when tackling uncertain or complex problems. New feature bets, customer discovery, or entering new markets demand Gardener thinking. [...]

Modernizing the Product Requirements Process

Few artifacts in product management are as debated as the Product Requirements Document (PRD). Once a cornerstone of software development, the PRD has been dismissed by many as a relic of the waterfall era. Agile evangelists often claimed that documentation slowed teams down, stifled creativity, and created rigid contracts rather than flexible collaboration.

Yet the pendulum has swung too far. In many organizations, the absence of structured requirements has led to chaos: misaligned expectations, duplicated effort, and wasted development cycles. The truth lies between extremes. The PRD is not obsolete, but it must be modernized to support how empowered teams work today.

The Problem with Traditional PRDs

In their original form, PRDs embodied the Architect mindset: meticulous, detailed, and designed for predictability. They outlined exhaustive feature lists, technical specifications, and user flows long before teams wrote code.

The strength of this approach was alignment—everyone could point to the same document. But the weaknesses were just as obvious:

  • Assumptions ossified into requirements before testing.
  • Discovery was separated from delivery, creating rework.
  • Teams treated the PRD as a contract, not a learning tool.

Traditional PRDs worked in environments where change was slow and costly. In today’s complex markets, they often create more inertia than clarity.

The Agile Pendulum

Agile pushed back hard against this rigidity. Inspired by the Agile Manifesto’s call for “working software over comprehensive documentation,” many organizations eliminated requirements documents entirely.

The intent was noble—faster cycles, more collaboration, tighter feedback loops. But the result was often Agile theater: teams running sprints and ceremonies without a shared understanding of what problem they were solving. Features shipped, but outcomes were unclear.

The lesson is clear: agility is not the absence of documentation. It is the presence of living artifacts that evolve with learning.

The Modernized PRD [...]

How to Make OKRs Work

This is Part 2 of a two-part series on OKRs inspired by John Doerr’s book Measuring What Matters. You can read Part 1 here: Why OKRs Matter.

OKRs are simple to understand, but deceptively hard to get right. Many teams write OKRs once, post them in a slide deck, and never look back. Others confuse them with KPIs or use them as a laundry list of tasks. The result is disappointment: OKRs become busywork rather than a framework for focus.

The good news is that with a few practical habits, OKRs can become a powerful engine for alignment and progress.

1. Write Strong Objectives

A good objective should be qualitative and inspiring, not vague or technical. It should describe a meaningful direction: “Delight customers with faster onboarding” is better than “Improve onboarding UI.”

If your team can’t rally behind the objective, you may need to rethink it. As Google’s OKR examples show, objectives should give teams purpose, not just describe work.

2. Make Key Results Measurable

The power of OKRs lies in the key results. They must be specific and quantifiable. Instead of saying, “Improve performance,” write, “Reduce page load time from 3 seconds to 1 second.”

A simple test: if someone outside the team reads the KR, can they clearly tell if it has been achieved? If not, refine it.

3. Balance Top-Down and Bottom-Up

OKRs shouldn’t only cascade from leadership. The best practice is a mix of top-down and bottom-up: leadership sets strategic priorities, while teams propose OKRs that align to them. This balance ensures both direction and ownership.

As the Google re:Work guide notes, effective OKRs connect strategy to execution without stifling creativity.

4. Don’t Tie OKRs to Compensation

One of the most common mistakes is linking OKRs directly to bonuses or performance reviews. This undermines ambition. Teams will sandbag their goals to guarantee a payout instead of aiming for stretch outcomes.

OKRs should be about learning and stretching, not personal reward. Keep performance management and OKRs as separate systems.

5. Revisit, Don’t Shelf

OKRs are living tools, not set-and-forget artifacts. The rhythm matters:

  • Review progress weekly or biweekly.
  • Score OKRs at the end of the cycle.
  • Reflect on what worked, what didn’t, and what should change.

The discipline of revisiting OKRs regularly is what makes them effective.

Takeaway for Product Leaders

This week, pick one team OKR and stress-test it. Is the objective inspiring? Are the key results measurable? Does it connect to strategy? If not, refine it before moving forward.

OKRs only work if they’re written clearly, measured honestly, and revisited consistently. Done right, they align teams, drive accountability, and stretch ambition.

Do you want me to propose a short linking line at the top or bottom of each post (e.g., “This post is part of a two-part series on OKRs”), or should they remain completely independent?


This post is inspired by John Doerr’s Measuring What Matters, which shares how OKRs transformed organizations from Intel to Google.

Cultivating Strong Product Culture

Culture may feel intangible, but in product organizations it’s one of the strongest predictors of success. Teams with the right culture move faster, make better decisions, and consistently build products that matter. Teams without it often drown in process, produce outputs that don’t add up, and lose trust with customers and stakeholders.

A strong product culture doesn’t appear by accident. It is cultivated deliberately through leadership choices, organizational design, and team habits.

Technology as an Asset

The first marker of strong product culture is how the organization views technology. In weak cultures, technology is treated as a cost center—a necessary function that delivers features specified elsewhere. The result is feature factories: teams judged by velocity, not by customer or business impact.

In strong product cultures, technology is an asset. Teams are trusted to solve customer problems in ways that create leverage. They are not just delivering features; they are shaping outcomes. Companies like Atlassian explicitly frame engineering as a partner in solving problems, not a service provider.

This framing changes everything: it determines whether teams are motivated to innovate or resigned to execute.

Strong Product Leadership

Leadership sets the tone for culture. Strong product leaders create trust on three fronts:

  1. Competence — the ability to make sound decisions and guide teams effectively.
  2. Integrity — consistency between words and actions, ensuring promises are backed by delivery.
  3. Benevolence — showing genuine care for people, not just output.

Trust allows leaders to delegate decisions. Without it, organizations drift toward command-and-control, which slows teams and stifles initiative.

Great leaders also recognize that their responsibility is not just to their teams but to the system of collaboration across product, design, and engineering. Marty Cagan of SVPG argues that the best leaders enable teams to be “empowered,” not order-taking feature teams. This requires aligning product and technology roadmaps, resolving conflicts, and creating clarity of purpose.

Empowered Teams vs. Feature Teams [...]

Cultivating True Agile: From Process to Outcome

Few words in technology are as overused—and misunderstood—as Agile. Too often, teams say they are Agile because they run sprints, hold stand-ups, or use Jira boards. But rituals without outcomes are just theater. True agility is not about process compliance. It is about creating organizations that learn quickly, adapt continuously, and deliver meaningful results.

Agile Theater vs. True Agility

The Agile Manifesto was written to emphasize people, collaboration, and adaptability. Yet many organizations reduce it to ceremonies and frameworks. Teams check the boxes of sprint planning and retrospectives, but still ship features that don’t solve real problems.

This “Agile theater” creates a dangerous illusion of progress. Work looks busy. Metrics like story points trend upward. But if customers aren’t getting value, nothing has truly been achieved.

True agility is measured not by outputs but by outcomes. Did we reduce onboarding friction? Did we increase retention? Did we help customers achieve meaningful progress? Outcomes shift the focus from activity to impact.

As Marty Cagan of SVPG puts it, “Outputs are what we produce. Outcomes are the results they enable.”

Engineering Leaders with a Strategic Mindset

Strong product cultures rely on engineering leaders who see beyond execution. When engineering is framed as a cost center, teams fall into feature-factory mode—delivering tickets without questioning value.

By contrast, empowered engineering leaders embrace a strategic mindset. They ask: How can we leverage technology to solve customer problems in innovative ways? What experiments will teach us the fastest? Which trade-offs maximize long-term impact?

Companies like Atlassian explicitly frame their engineers as partners in shaping outcomes. This mindset shift transforms engineering from a delivery arm to a value creator.

Modern Product Discovery

In true Agile organizations, discovery and delivery happen continuously and in parallel. Discovery is not about writing exhaustive requirement documents. It’s about reducing uncertainty before committing resources. [...]

Love the Problem, Solution will Follow

When you’re building a product, it’s easy to get excited about the “how.” The sleek design, the advanced tech stack, the long feature list. But here’s the hard truth that separates great products from forgettable ones: don’t fall in love with the solution; fall in love with the problem.

This mindset shift can be the difference between a product that thrives and one that just exists. Albert Einstein once said, “If I had an hour to solve a problem, I’d spend 55 minutes thinking about the problem and five minutes thinking about solutions.” The best product builders know this to be true.

Consider Airbnb. Before scaling globally, its founders lived with hosts, took photos of their homes, and listened carefully to their frustrations. They didn’t start with “how to build an online rental platform.” They started with the problem: people struggled to find affordable, authentic places to stay, and hosts struggled to attract guests. By falling in love with this problem, they built a solution that scaled.


Why Focus on the Problem?

Our brains are wired to leap into solution mode. But this creates danger: assumptions are the most dangerous trap in product management. When teams build on assumptions, they risk creating features no one truly values. This is how companies become “feature factories,” busy shipping but failing to create traction or business impact.

The goal isn’t just to build things right—it’s to build the right things. Robust infrastructure and pixel-perfect design mean little if the product doesn’t solve customer problems or deliver business value.

Melissa Perri, author of Escaping the Build Trap, describes this trap as the endless pursuit of features without focusing on outcomes. Avoiding it requires a disciplined focus on understanding and framing the problem first (SVPG on discovery vs. documentation).


How to Fall in Love with the Problem

Shifting to a “problem-first” mindset takes deliberate practice. Here are seven techniques to help cultivate it. [...]

Why OKRs Matter

This is Part 1 of a two-part series on OKRs inspired by John Doerr’s book Measuring What Matters. In Part 2, we’ll explore how to make OKRs work in practice.

Most organizations don’t fail because of a lack of effort. They fail because energy is scattered across too many priorities. Objectives and Key Results, or OKRs, provide a way to channel focus toward what truly matters.

An OKR has two parts:

  • Objective: a clear, inspiring goal.
  • Key Results: 3–5 measurable outcomes that indicate progress toward the objective.

This simple framework has powered the growth of companies from Intel to Google. John Doerr introduced OKRs at Google when the company had fewer than 50 employees. The practice stuck, and today, OKRs are one of the most widely adopted goal-setting systems in technology and beyond.


The Four Superpowers of OKRs

In Measuring What Matters, Doerr describes OKRs as more than a tracking tool. Done right, they create four superpowers:

  1. Focus and Commit to Priorities

Instead of chasing ten things poorly, OKRs force teams to concentrate on a handful of high-impact goals. A clear OKR tells the team, “This is what matters most right now.”

  1. Align and Connect Teams

OKRs cascade across levels, making sure teams are pulling in the same direction. As Google’s OKR story illustrates, alignment ensures efforts add up instead of canceling out.

  1. Track for Accountability

Key results are measurable. You either achieved them or you didn’t. This creates transparency and accountability without requiring micromanagement.

  1. Stretch Beyond Comfort

Ambitious OKRs encourage teams to aim higher than they otherwise might. By setting targets that are challenging but not impossible, teams unlock innovation.


What OKRs Are Not

It’s easy to misuse OKRs. They are not:

  • A to-do list. Tasks belong in project management tools. OKRs should describe outcomes, not activities.
  • A KPI system. Metrics are useful, but OKRs are about progress toward goals, not operational reporting.
  • A replacement for strategy. A strategy explains why you’re pursuing a goal. OKRs translate that strategy into what progress looks like this quarter or year.


Quick Example

Suppose your objective is: Delight customers with faster onboarding.

Key results might be:

  • Reduce onboarding time from 10 minutes to 3 minutes.
  • Achieve a 95% completion rate for setup.
  • Improve NPS for onboarding from +20 to +40.

Notice how each key result is measurable. The objective is aspirational; the key results tell you when you’ve arrived.


Takeaway for Product Managers

This week, write down one objective for your product. Then, add three measurable key results that define success. If you can’t measure progress, refine until you can.

OKRs are not about bureaucracy. They’re about clarity, alignment, and ambition. Done right, they help teams build products that matter.


This post is inspired by John Doerr’s Measuring What Matters, the definitive guide to the OKR framework and how it drives progress at scale.