GardenIQ

Status

hiatus

Plants

50

Pairings

267

Hard part

rules before AI

why

My dad is a gardener with the kind of spatial reasoning I’d call savant-level if I weren’t his daughter. He looks at a bed and knows where the tomatoes go, why the squash needs more room than the seed packet says, which sprout isn’t a weed yet. I’ve tried gardening twice and failed twice. The thing I lost wasn’t motivation or the right tools; it was the silent decisions in his head, the ones he doesn’t bother explaining because they’re so obvious to him.

GardenIQ is the tool I wished I’d had: an attempt to encode the kind of reasoning my dad does for free, for the gardener who doesn’t have him to call. Most tools in this space chase the absolute beginner with surface-level companion advice (tomatoes love basil, hate fennel). Easy to ship; doesn’t help. GardenIQ goes the other way: companion conflicts flagged with their mechanism, spacing warnings drawn on a canvas, timing anchored to your zone’s last frost rather than the wall calendar. The why on every recommendation is the part a gardener-without-an-expert is actually missing.

what I built

A single-page planner with no account and no backend. Four pieces:

• Garden canvas (Konva): drag-and-drop, grid overlay, zoom and pan, multiple named beds. Every plant carries its own spacing radius; the canvas warns you when two plants overlap.
• Companion-planting layer: ranks pairings on a 1–3 strength scale, deduplicates reverse pairs (tomato-basil and basil-tomato are the same recommendation, not two), and surfaces why each pairing helps or hurts.
• Succession timeline: converts “start indoors 6 weeks before last frost” into an actual calendar date for your zone. Offset and clone successive sowings without rebuilding the schedule.
• Climate layer: zip-code lookup pulls USDA zone, first and last frost, average rainfall. Shapes every other recommendation downstream.

An export pipeline snapshots the canvas, renders the companion matrix, and assembles a printable plan: PDF for your fridge, email for your collaborator, a shareable link that carries the whole plan in the URL. No account, no backend, no plan-retention policy to write: your plan is the link, the same way it is for Office Hours.

the database

The rule layer is fifty plants and 267 companion pairings, hand-curated from horticultural references. Each plant entry carries:

• Identity: scientific name, family, category
• Spacing: minimum, recommended, row-spacing in inches
• Frost-relative timing: indoor start, transplant, direct sow, days to maturity
• Climate: USDA zones, sun, water, soil pH ranges
• Pest and disease relationships
• Companions: typed beneficial / neutral / antagonist, ranked 1–3, each with a one-sentence mechanism

The mechanism is the load-bearing part. Repels aphids and whiteflies is doing different work than both heavy feeders, compete for nutrients. A tool that flattens both into a green check or a red X has thrown away the part the gardener was supposed to learn.

decisions I’d defend

Rule-first, AI-second. The companion-planting database is curated. The spacing math is deterministic. The timeline rules come from horticultural references, not the model. The Anthropic API enters as a second layer: an Optimize My Garden call that explains tradeoffs, suggests substitutions, and flags risks the rule database might have missed. AI as a second pair of eyes, not a first-draft generator. Same architecture under Pocketbook (model captions, human edits) and Celine AI (statutes as ground truth, model as pattern-matcher).

Encode expert reasoning, don’t simplify it down. Most beginner-targeted tools translate a savant’s mental model into yes/no labels and lose the part that actually teaches: the why. GardenIQ keeps the why on every recommendation. A tooltip that names the strength score, sources the mechanism, and flags airflow risk at close spacings is the kind of detail beginner tools strip out. The struggling gardener doesn’t need fewer details. She needs the right ones, surfaced when the decision is in front of her.

URL is the whole plan. No accounts in the MVP. Plans encode into a compressed URL parameter, share like a Spotify link, reopen on any device. Costs me persistence (no plant-tracking-over-time, no notifications, no social) and buys me a deploy story that survives me: same shape that lets Office Hours keep working without a server behind it.

Frost-date-relative scheduling. Every recommendation in the timeline anchors to your last frost, not the wall calendar. The same plan works for a Wisconsin gardener and a Texas gardener: absolute dates resolve differently, relative spacing of indoor-start, transplant, direct-sow, and harvest stays correct.

the receipts

The rule engine is one TypeScript function. The antagonist branch, verbatim from companion.ts: the part that fires the X conflicts with nearby plant warning when a placement matches:

for (const comp of plant.companions) {
  if (!placedPlantIds.has(comp.plantId)) continue;

  if (comp.type === 'antagonist') {
    recommendations.push({
      type: 'conflict_warning',
      severity: 'critical',
      title: `${plant.commonNames[0]} conflicts with nearby plant`,
      body: comp.reason,
      affectedPlantIds: [plant.id, comp.plantId],
      bedId: placement.bedId,
      source: 'rule_based',
    });
  }
}

// Deduplicate: A→B and B→A are the same conflict
return recommendations.filter(/* sort + dedup */);

No model in the loop. The function reads the static plant database, walks every placement on the canvas, and emits a warning whenever an antagonist pair lands within range. The mechanism (Fennel inhibits tomato growth, Both heavy feeders, compete for nutrients) comes straight from the data record’s comp.reason field. The model arrives later, on the Optimize My Garden call, with the rule output already in hand.

what I learned

Naming the right unit makes the rest of the schema small. Once last-frost-relative dates were the calendar primitive, succession planting fell out almost for free: every successive sowing is just an offset off the same anchor. Most garden-planning code I read was wrestling with absolute calendar dates and re-deriving zone offsets at every render. Pinning the data layer to the relative anchor made the rest of the code uneventful.

Companion scoring is a deduplication problem in horticulture clothing. The N×N companion matrix is symmetric: tomato-basil and basil-tomato are the same recommendation, not two. A tool that doesn’t dedupe surfaces the same advice twice, which erodes trust in the entire database. Unglamorous and load-bearing.

AI is most useful when the deterministic core is already correct. The model sees the user’s plan, the climate context, and the rule output, and adds analysis the rules can’t easily encode (variety substitutions, rotation suggestions, pest-window calls). The shortcut would have been a chat surface over a horticulture prompt: fluent, fast, mostly wrong. The questions a serious gardener asks have right answers and wrong ones, and fluent-sounding answers from a model unanchored from data are exactly how trust gets lost. Get the deterministic core right, then let the model help.

what’s next

GardenIQ is live at gardeniq.hosette.net and currently on hiatus: an early Lovable build I shipped enough of to use, then set down so other work could move. The canvas works, the companion library is in, the AI recommendations land. The polish backlog is real:

• URL versioning
• Print-PDF flow on letter and A4
• Rough edges around bed rotation and the auto-plant prompt

I’ll get back to it when the next gardening season makes the missing pieces obvious. Plant-tracking-over-time is the longer arc: a what I actually planted vs. what I planned view is the bridge to seasons two and three, and that arc only matters if I’m using the tool for real. For now: the rough edges are honest about where the project is, and the project is honest about where the gardener is.