How to Grow an Existing App with AI Skills

You have an app. People sign up. Then most of them quietly disappear. Your charts go up and to the right — total registered users, total downloads, cumulative everything — but the truth is hiding underneath: each week’s new cohort retains a little worse than you’d like, daily actives are flat, and the activation funnel leaks where it always has. This is the hardest stage of a product’s life, because nothing is obviously broken. The app works. It just doesn’t stick.

Growth here is not a bigger marketing budget. Pouring acquisition into a product that doesn’t retain is the classic leaky bucket: you pay to fill the top while the bottom drains. The real work is closing the bucket — turning first-time users into activated users, activated users into habitual users, and habitual users into people who would be genuinely annoyed if your app disappeared. That is an engineering and design problem with a known shape, not a mystery.

This guide gives you a sequenced workflow that an AI coding agent can execute alongside you, step by step. You will design a habit loop with Hooked UX, make your first-run action reliable with Improve Retention, set up a weekly cadence of customer learning with Continuous Discovery, replace endless internal debate with cheap experiments using Lean UX, restructure how the team decides what to build with Inspired, point the whole company at the one number that matters with Lean Analytics, polish the small moments with Microinteractions, and sustain it all on intrinsic motivation with Drive Motivation.

You don’t grow a leaky-bucket app by pouring in more water. You grow it by fixing the bucket — one cohort, one loop, one micro-moment at a time.

Each skill packages a bestselling book into something your agent can apply directly to your codebase, your funnel, and your copy. You install one with npx skills add wondelai/skills/<slug> --global and invoke it by telling the agent to use it. Work through the phases in order — they build on each other — and by the end you’ll have a retention engine you can keep turning long after this guide.

Phase 1 — Design the habit loop that brings users back

Start with the engine of return: the habit loop. Hooked UX is built on Nir Eyal’s Hook Model — Trigger → Action → Variable Reward → Investment — a four-phase cycle that, run frequently enough, moves your app from a deliberate choice to an automatic one. The insight that matters most for an existing app is the migration from external triggers (your push notifications, your re-engagement emails) to internal triggers (an emotion the user feels — boredom, anxiety, FOMO, the itch to check something). If after thirty days your users still need a notification to come back, no internal trigger has formed, and you’re renting attention rather than owning a habit.

Map your existing product against all four phases before you change anything. What emotion does someone feel right before they open your app? What is the simplest action they take — and is it genuinely simple, or does it sit behind a load screen and three taps? Is the reward variable (you never quite know what you’ll get) or predictable (the dopamine fades the third time)? And does the user invest something — data, content, a preference, a connection — that makes the next loop better and loads the next trigger? A loop with a weak phase doesn’t half-work; it stalls.

The variable reward is where most utility apps go flat. A to-do app that shows the same empty checklist every morning has a predictable reward; one that surfaces a streak, a surprise insight from your week, or what your teammates touched while you were away taps the three reward types Eyal names — tribe (social validation), hunt (a stream of resources), and self (mastery and progress). Ask your agent to design reward variability that fits your product honestly, not a slot-machine bolt-on.

Crucially, sequence the loop correctly: ask for investment after the reward, never before. Users invest when they feel good, and each investment — saving a draft, following a topic, inviting a teammate — should both raise switching costs and load the next trigger (your post creates a notification when someone replies). Have the agent re-engineer your onboarding so a new user completes one full Hook cycle before they ever leave the first session. That single change is often the difference between a Day-1 number and a Day-7 number.

Phase 2 — Fix activation by making the first action almost effortless

A habit loop only matters if users reach it. Improve Retention brings BJ Fogg’s Behavior Model — B=MAP, where Behavior happens only when Motivation, Ability, and a Prompt converge at the same moment — to the activation problem. The strategic core of the book is counterintuitive and liberating: motivation is unreliable and you can’t engineer it, but ability you can. Every field you remove, every step you collapse, every smart default you set moves the behavior to the right on the model, crossing the Action Line even when motivation is low. Stop trying to pump up excitement; make the thing easier.

The most useful diagnostic the skill gives you is the Ability Chain: simplicity is governed by the scarcest of six resources — time, money, physical effort, mental effort, social deviance, and non-routineness. Teams reflexively optimize time (“now it’s three taps instead of five”) when the real bottleneck is mental effort (the user doesn’t understand what to type) or non-routine (you’re asking them to do something they’ve never done). Fixing the wrong link does nothing. Have your agent run the friction audit on your real activation flow and name the actual bottleneck.

Then shrink the target behavior to its Starter Step — the tiniest meaningful version. The goal of onboarding is not “complete your profile” (that’s a project, not a behavior); it’s “fill in one field,” “open the dashboard,” “send one comment.” Momentum from a completed micro-action does more for retention than any aspirational tour. And pair every Starter Step with a celebration: an immediate, honest moment of success, because repetition alone doesn’t wire a habit — the feeling of success does. This is exactly where most onboarding flows are silent and cold.

Finally, fix your prompts. A push notification sent to a user below the Action Line — without the motivation or ability to act — is spam, and every unnecessary prompt degrades the value of the next one. The skill’s rule is to prompt only on real events and to anchor new behaviors to existing routines (“after I open Slack, I will…”). Switch your re-engagement from time-based (“We miss you!”) to event-based (“Your weekly report is ready”). Ask the agent to redesign your notification strategy around the question: would I genuinely appreciate receiving this right now?

Phase 3 — Run continuous discovery so you stop guessing

By now you’ve improved the loop and the funnel based on best-practice diagnosis. But to keep growing you need a steady stream of evidence about your users, not generic patterns. Continuous Discovery brings Teresa Torres’s framework for embedding customer learning into the weekly rhythm of product work — the benchmark being at least one customer touchpoint per week, every week, by the product trio (PM, designer, engineer), not a quarterly research burst that goes stale by week two.

The centerpiece is the Opportunity Solution Tree: a living visual that connects a desired outcome at the top, to customer opportunities (needs and pain points, framed from the customer’s perspective) in the middle, to candidate solutions and experiments at the bottom. Most teams leap straight from “increase retention” to “let’s build streaks” — skipping the entire opportunity space and betting everything on one untested solution. The tree forces you to understand why users drop off before you decide what to build, and to pursue several opportunities at once instead of betting the quarter on a hunch.

Pair the tree with a current-state experience map and a weekly interview habit. Map how churned users actually try to accomplish their goal today — step by step, including thoughts and feelings — and the high-emotion failure points become opportunities on the tree. Then make interviews story-based: ask “tell me about the last time you…” rather than “would you use…”, because customers are poor predictors of their own behavior but reliable narrators of what they actually did. Each interview becomes a one-page snapshot the whole team can absorb.

The discipline that protects you from building on sand is assumption testing. Before committing engineering, identify the assumptions a solution rests on — desirability, viability, feasibility, usability — map them by importance versus existing evidence, and test the riskiest leap-of-faith assumptions first with the smallest possible experiment. A painted-door button measuring click-through can invalidate a feature in days that would otherwise eat a month of build time. Have the agent map the assumptions hiding inside your next planned feature and design the cheapest test for the scariest one.

Phase 4 — Replace debate with cheap experiments using Lean UX

Discovery surfaces opportunities; Lean UX turns them into testable bets instead of endless meetings. Jeff Gothelf and Josh Seiden’s core shift is from outputs to outcomes: the value of a design is the change in user behavior it produces, not the fidelity of the deliverable or the fact that it shipped. The method compresses the distance between idea and evidence — declare your assumptions, write a hypothesis, run the smallest experiment that could disprove it, and let real behavior settle the argument.

The hypothesis statement is the workhorse. Instead of “make onboarding better,” you commit to a falsifiable prediction in a fixed format: “We believe [outcome] will happen if [persona] achieves [action] with [feature],” with the success metric and threshold agreed before you run the test so you can’t move the goalposts afterward. This is the antidote to the three-week design debate where two mockups and zero data go in circles.

Match experiment fidelity to assumption risk: a paper prototype tested with five users in an afternoon (which uncovers roughly 85% of usability problems) beats a fully coded redesign when the question is “do users even understand this?” Reserve expensive A/B tests for when you already know the concept works and you’re tuning the margin. Have the agent pick the cheapest experiment that answers your actual question, and run a collaborative design-studio session — where engineers and the PM sketch alongside the designer — so the whole team shares understanding rather than waiting on a 40-page spec.

The last Lean UX discipline matters for sustaining growth: when a hypothesis is invalidated, remove the feature from the backlog — don’t defer it. A backlog full of disproven ideas is a graveyard that drags on every planning session. Treating a killed experiment as a win, not a failure, is what keeps learning velocity high.

Phase 5 — Build the right things with an empowered team

Growth stalls when a team becomes a feature factory — shipping whatever stakeholders request, measuring stories-shipped instead of outcomes, nobody owning whether any of it moved a metric. Inspired brings Marty Cagan’s model of empowered product teams: small, durable, cross-functional groups given problems to solve rather than features to build, accountable for outcomes (activation, retention, revenue) rather than output. The difference between a feature factory and a growth engine is whether your people are missionaries who believe in what they build because they discovered it, or mercenaries executing a handed-down backlog.

The mechanism is dual-track: discovery (deciding what’s worth building) runs continuously and cheaply alongside delivery (building production-quality software). Discovery exists to address four risks before you spend engineering time — value (will customers use it?), usability (can they figure it out?), feasibility (can we build it?), and viability (does it work for the business?). Cagan’s rule of thumb is sobering: expect ten to twenty discovery iterations for every feature that reaches delivery, because most ideas don’t survive contact with real users. Failing fast and cheap in discovery is the whole point.

Two habits from the book compound especially well for an existing app. First, get engineers into discovery, not just delivery — they’re the best source of innovation because they know what’s newly possible, and a clickable prototype tested with five target users will save you a quarter of misdirected building. Second, give the team strategic context so it can make good autonomous calls: a real product vision (the world you’re building toward) and a quarterly strategy that sequences the hard choices — which users first, which problems first. Outcome-based roadmaps that name problems to solve, not features with delivery dates, are what let an empowered team out-decide any top-down plan.

Phase 6 — Measure the one number that actually matters

You cannot grow what you cannot see honestly, and most dashboards lie by flattering. Lean Analytics distills Croll and Yoskovitz’s discipline into a single demand: focus on the One Metric That Matters right now — the number that tells you whether the riskiest part of the business is working — and treat everything else as drill-down. A good metric is comparative, a ratio or rate (not an ever-growing total), and behavior-changing: if a number won’t change what you do next, stop watching it. The cumulative up-and-to-the-right chart is the single most reliable vanity tell, because totals can’t go down and so they hide the decay underneath.

Two ideas reframe how you read your own data. First, business model dictates which metrics matter — a habitual app lives on DAU/MAU and retention cohorts, a SaaS on churn and time-to-value, a marketplace on liquidity — so stop copying another company’s north star. Second, stage dictates sequencing: the Lean Analytics stages run Empathy → Stickiness → Virality → Revenue → Scale, and working a later stage’s metric before passing the current gate is the canonical startup mistake. An app with weak retention is squarely in the Stickiness stage, which means retention is your OMTM — and pouring referral or paid-acquisition effort in now just multiplies a leaky bucket faster.

Then draw a line in the sand: a target number, a date, and a pre-committed answer to “what do we do if we miss?” — decided in advance, so “good enough” is a decision rather than a rationalization made after results arrive. Pair the OMTM with a counter-metric so it can’t be gamed (activation speed paired with 30-day retention; a referral push paired with the quality of referred users). And make time honest with cohorts: track each signup month separately, because real improvement vanishes inside a blended average and a flat aggregate often hides one segment soaring while another collapses.

Phase 7 — Polish the micro-moments that make it feel alive

With the loop, funnel, discovery, and metrics in place, the remaining gap between an app people tolerate and one they love lives in the details. Microinteractions brings Dan Saffer’s four-part structure — Trigger → Rules → Feedback → Loops & Modes — to the tiny contained moments users touch every day: the toggle, the like button, the pull-to-refresh, the loading state, the form field. These are too small for users to think about consciously, but they feel every one, and they accumulate into the sense that a product is either crafted or assembled.

Feedback is where most apps feel dead. The rule is immediate — under 100ms for direct manipulation — and proportionate: a small action gets small feedback, a big result gets a big one. Prefer animating the element the user already touched (the button itself becoming “Saving…”) over throwing a separate toast. And the most overlooked discipline is edge cases: map every state — empty, loading, partial, full, error, disabled, double-tap — because an interaction that breaks at zero or on a repeated tap is exactly what erodes trust.

Invest in one or two signature moments — a distinctive interaction that becomes part of your product’s identity, like the moment a task completes or a goal is hit — but apply the removal test: if users wouldn’t miss it, it’s decoration, not signature, and it shouldn’t slow down a frequent action. Use long loops to let interactions mature: show the “swipe to archive” hint for the first three sessions, then retire it through progressive reduction so power users aren’t nagged forever. Have the agent implement the actual code for these, not just describe them.

Phase 8 — Sustain engagement with intrinsic motivation

Everything above can be turned against the user, and if you do, growth reverses. Drive Motivation brings Daniel Pink’s synthesis of motivation science: for any task requiring even rudimentary cognitive effort, external “if-then” rewards either don’t work or actively make things worse — they extinguish intrinsic motivation, crush creativity, and foster short-term thinking. Lasting engagement comes from Autonomy, Mastery, and Purpose (AMP), and this is the lens that keeps your habit loops and gamification from curdling into something users come to resent.

Autonomy means choice over what, when, how, and with whom. The autonomy killers are exactly the patterns growth teams reach for under pressure: forced linear tutorials, unskippable steps, algorithm-only feeds with no user control, mandatory notifications. Audit your app for “you must complete X before Y” and replace it with chosen paths. Mastery means the desire to get better at something that matters — visible progress, immediate feedback, and challenge calibrated to skill so the user sits in flow between boredom and anxiety, with always a clear next step. Purpose is the context that makes the other two cohere: does the user know why this exists, and can they see their impact on something bigger than a vanity number?

The most common self-inflicted wound is awarding points for everything, which crowds out the intrinsic satisfaction that was driving your best users in the first place. Reserve rewards for genuinely meaningful milestones, prefer “now-that” recognition (an unexpected acknowledgment after the fact) over “if-then” bargains, and watch the line where a streak stops being a proud record of mastery and becomes a fear of loss you’re exploiting. Sustainable growth runs on Type I behavior — fueled by AMP — because it’s renewable and it promotes the user’s well-being, which is the only kind of engagement that compounds for years instead of burning out in a quarter.

Engagement you have to manufacture every morning isn’t a habit — it’s a treadmill. The loops worth building are the ones users would choose even if you stopped reminding them.

Your checklist

• Map your app’s core loop against the four Hook phases and fix the weakest one (Hooked UX)
• Identify the internal trigger — the emotion — that should pull users back without a notification
• Add honest variable reward to your most frequent screen, sequencing investment after reward
• Run a B=MAP friction audit on activation and name the scarcest Ability Chain resource (Improve Retention)
• Shrink your first-run flow to a Starter Step that delivers value in under 30 seconds, with a celebration
• Switch re-engagement from time-based to event-based prompts that pass the “would I appreciate this?” test
• Build an Opportunity Solution Tree for your retention outcome and keep it living (Continuous Discovery)
• Establish a weekly story-based interview cadence with automated recruitment and one-page snapshots
• Map the assumptions inside your next feature and test the riskiest one with a painted-door experiment
• Convert your biggest internal design debate into a Lean UX hypothesis with a pre-committed metric (Lean UX)
• Choose the lowest-fidelity experiment that answers the question; remove invalidated items from the backlog
• Write an opportunity assessment for your top three backlog requests and kill the weakest (Inspired)
• Replace your dated feature roadmap with outcome-based problems to solve and key results
• Identify and retire vanity metrics; pick your One Metric That Matters for the Stickiness stage (Lean Analytics)
• Draw a line in the sand — target, date, miss response — and pair the OMTM with a counter-metric
• Rebuild your dashboard cohorted and segmented, OMTM big, six supporting metrics max
• Audit your five most-used interactions and add sub-100ms feedback plus missing edge-case states (Microinteractions)
• Implement one or two signature moments that pass the removal test
• Audit gamification against Autonomy, Mastery, and Purpose; fix autonomy violations (Drive Motivation)
• Replace “if-then” rewards with “now-that” recognition reserved for meaningful milestones

Common mistakes

Buying growth before fixing retention. The single most expensive error at this stage is spending on acquisition while cohorts still decay. Lean Analytics is explicit: virality and paid acquisition poured into a product that doesn’t retain just multiply churn. Pass the Stickiness gate — a flattening retention curve — before you open the acquisition spigot.

Relying on external triggers forever. If thirty days in your users still need a push to return, you have a notification dependency, not a habit. Hooked UX is clear that the goal is migrating users to internal triggers. Notifications are scaffolding to bridge the gap until the emotional cue forms — not the load-bearing wall.

Optimizing the wrong link in the Ability Chain. Teams celebrate shaving a step off onboarding when the real bottleneck was mental effort or non-routineness, so the metric doesn’t budge. Rate all six factors and fix the scarcest resource, not the most obvious one.

Prompting below the Action Line. Sending “We miss you!” to a user with neither the motivation nor the ability to act is spam, and it degrades every future notification. Prompt only on real events, anchored to existing routines.

Jumping from outcome straight to solution. “Retention is low, let’s add streaks” skips the entire opportunity space. Build the Opportunity Solution Tree first; the streak might be the worst of five options you never considered.

Testing the easy assumption instead of the risky one. It feels productive to validate something, so teams test what’s convenient and leave the fatal assumption untouched. Map by importance versus evidence and test the leap-of-faith assumption first.

Measuring outputs, not outcomes. Stories-shipped and features-launched feel like progress and change nothing. Both Inspired and Lean UX insist that success is a change in user behavior. Instrument every release so you can tell.

Gamifying with points for everything. The fastest way to kill the intrinsic motivation driving your power users is to slap extrinsic rewards on every action. Drive warns that “if-then” rewards crowd out the very engagement you’re trying to grow. Reserve rewards for meaningful milestones and protect autonomy.

Polishing microinteractions before the loop works. Delightful animations on a product nobody returns to is rearranging deck chairs. Sequence matters: loop and activation first, discovery and metrics to steer, and only then the micro-moment polish that turns “fine” into “loved.”

Frequently asked questions

In what order should I actually use these eight skills?

Follow the phases as written — they’re sequenced deliberately. Start with Hooked UX and Improve Retention because the loop and activation are the bucket you’re trying to seal. Layer in Continuous Discovery and Lean UX next so you’re steering with evidence instead of opinion, and use Inspired to fix how the team decides what to build. Bring in Lean Analytics early in parallel as your instrument panel — you’ll want the baseline before and after every change. Microinteractions and Drive Motivation come last not because they’re optional but because their payoff depends on a loop that already works and metrics that can prove the lift. That said, the skills compose freely; if your problem is clearly a measurement problem, lead with Lean Analytics.

Do I need a team, or can a solo founder do this?

A solo founder can do all of it — that’s part of the point of having an AI agent execute alongside you. Continuous Discovery and Inspired describe a “product trio,” but the underlying habits scale down: you can run one story-based interview a week, keep a personal Opportunity Solution Tree, and write your own opportunity assessments. The agent fills the gaps in skill you don’t have — drafting the interview snapshot template, implementing the microinteraction in your component, building the cohort view. Where a real team helps is in collaborative design studios and dividing discovery from delivery, but none of these skills require headcount to start.

How is this different from just A/B testing everything?

A/B testing is one experiment type, and an expensive, slow one best reserved for tuning a concept you already know works. The Lean UX point is to match fidelity to risk: when the question is “do users even understand this?”, five users and a paper prototype answer it in an afternoon and uncover most usability problems, whereas a coded A/B test needs traffic and weeks. More fundamentally, testing without discovery means you’re optimizing solutions you never validated were worth building. Continuous Discovery and Inspired make sure you’re testing the right things; Lean UX and Lean Analytics make sure you test them cheaply and read the results honestly.

Isn’t building habit loops manipulative?

It can be, and Hooked UX takes this seriously with the Manipulation Matrix — a two-by-two of whether the maker uses the product themselves and whether it genuinely improves the user’s life. Aim to be a “Facilitator”: you use it, and it helps. Drive Motivation is the ethical backstop for the whole stack — if your engagement depends on autonomy violations, loss-aversion streaks, or rewards that crowd out genuine interest, you’re building a treadmill users will come to resent and abandon. The durable version of growth makes staying the better choice through real value, not artificial switching costs or manufactured anxiety.

How long before I see results?

The fastest wins are usually in activation and microinteractions — a friction audit that finds the real Ability Chain bottleneck, or sub-100ms feedback on a dead-feeling core action, can move numbers within a single cohort. Habit formation is slower by nature: Hooked UX uses the “5% rule” — a habit has formed when at least 5% of users show unprompted return — and that takes weeks of loop iteration to read. The discovery and metrics habits are investments that compound: the first weekly interview teaches you little, but twelve of them rewire your intuition about what to build. Set lines in the sand with realistic dates so you’re judging each change against a pre-committed bar, not a moving one.

Start growing your app today

Pick the phase that matches your sharpest pain — leaky activation, a loop that doesn’t loop, a dashboard nobody trusts — and install the skill that owns it. Each one packages a definitive book into something your agent can apply directly to your code, your funnel, and your copy, today.

Install the full stack with npx skills add wondelai/skills --all --global (or add them one at a time, e.g. npx skills add wondelai/skills/hooked-ux --global), then tell your agent which one to use and point it at a real artifact — your onboarding flow, your retention cohort, your most-used screen.

When you’ve sealed the bucket and you’re ready to make the product itself sharper — performance, accessibility, the quality of the experience — read How to Improve an Existing App with AI Skills. And if growth depends as much on the business around the app as the app itself, see How to Grow an Existing Business with AI Skills.