Skip to main content

WEFA 2026 V1 — Product Vision

Document Ownership​

Diagnosis​

In todays modern world technology has driven us to isolation and physical disconnection from family, peers, community and nature

  • What that looks like day-to-day
    • “Fun” is increasingly screen-only, indoors, and solo.
    • Environmental work (gardening, stewardship, nature learning) is often framed as worthy but not playable or social.
    • Digital products tend to centralize data and identity, leaving people without meaningful ownership or portability.
  • Why WEFA exists
    • Reframe plant care as a game loop (care → growth → reward → play) so nature connection becomes repeatable and fun.
    • Use story, creatures, and shared play to make “outside + together” the default outcome of “using tech.”

Guiding Policy​

Don’t fight technology embrace it and build a youth driven story and game experienced centered around plant, creature and games that through the emerging technologies of blockchains, AI, IoT and augmented reality create a symbiotic relationship between nature. community and the ever growing digital world.

  • Design posture
    • Local-first + privacy-first: the core loop must work offline, with user-owned data as the default.
    • Progressive enhancement: AR, onchain, and device sensors should upgrade the experience, not block it.
    • Octalysis “white-hat” motivation: prioritize meaning, progress, creativity, and social connection; avoid punitive scarcity loops.
  • Product posture (what we ship first)
    • A thin, lovable vertical slice of the loop: Plant → Reward → Creature → Game.
    • Keep “Phase 2+” features (full marketplace, full multiplayer, ZK proofs, tokenbound, advanced AR anchoring) behind interfaces/stubs so V1 stays buildable and demoable.
  • Technology posture (how we keep it extensible)
    • Model the world with an ECS-style data layer (entities + components) so Plants, Creatures, Games, and Spaces evolve without rewriting the whole app.
    • Use XState machines to make flows explicit, testable, and easy for coding agents + collaborators to extend.

Coherent Action​

  • Build an app prototype that enables the core game loop
    • Deliver the “V1 proof outcomes” that can be demonstrated in a single session:
      • onboarding (passkey/wallet) → add plant → record care → earn energy → nurture/evolve creature → play a game
    • Ship Tic-Tac-Toe in two modes:
      • baseline “always works” (non-AR) + optional AR renderer when WebXR is available
    • Implement clean seams (interfaces) for:
      • Plant verification (PlantID proxy or stub)
      • Creature generation (seed pack / LLM / future on-device inference)
      • Rewards (local-first now; attestations later)
  • Write the story the apps foundation is built upon
    • Establish V1 canon that explains the “why” of caring + playing:
      • element choice matters
      • place/biome matters
      • the player’s actions restore balance between worlds
    • Translate story into production constraints:
      • onboarding copy + tone
      • CreatureCard schema fields (name, element, traits, signature move, short lore)
  • Apply to funding and grant programs showcasing the prototype
    • Use the prototype as the “proof of loop” and attach:
      • screenshots/video of plant care → creature change → gameplay reward
      • a clear roadmap from local-first prototype → community spaces → onchain attestations/ownership
    • Frame WEFA’s differentiation as: phygital + youth story + local ecology education + user-owned game assets.

Assumptions​

  • People care about plants - Test in V1: can a new user add a plant + complete 3 care events in their first week?
  • People will like the story - Test in V1: do users remember their chosen element + creature name/lore and share it?
  • It can gain investment as an impact based tool - Test in V1: can we report measurable signals (care events, streaks, local engagement sessions, learning outcomes) without compromising privacy?

Cynefin​

Complicated → Clear

  • Strategy for moving “complicated” domains toward “clear” execution
    • Standardize the inner loop (plant → reward → creature → game) as predictable “best practice.”
    • Keep risky/variable edges (AR device compatibility, onchain UX friction, sensor permissions) as optional modules and stubs until the loop is stable.

Long Term Outcomes​

  • WEFA enshrines nature and community as core principles for future generations
    • A cultural artifact (story + game + rituals) that makes stewardship feel normal, social, and fun.
    • A creative platform where players co-create creatures, cards, and local ecology knowledge.
  • WEFA supports user-generated and agent-generated experiences without losing trust
    • Players, educators, and creators can publish creature packs, shrine challenges, board variants, and lore while preserving provenance.
    • AI agents can assist with content generation and moderation, but canonization remains transparent and rule-driven.
  • WEFA is core infrastructure in the Inland Empire in California helping to manage community and nature relationships in a fun manner
    • “Shrines” as community spaces that coordinate local plant care, nature play, and learning.
    • A local-first data layer that communities can opt into sharing/attesting when it benefits them.
  • WEFA World is cumulation of the story and game of WEFA into a live physical experience at thematic scale
    • A physical + digital destination where AR play, learning, and stewardship become a shared ritual.
    • A place where schools, families, and communities run seasonal events tied to the WEFA lore map.
    • A persistent autonomous world layer where public milestones, seasonal goals, and community-owned spaces can be verified onchain.

Short Term Outcomes​

  • Player can login the app with either passkey or Ethereum wallet
    • Passkey path: WebAuthn-based sign-in (fast + phishing-resistant).
    • Wallet path: standard EVM wallet connection (and later “thin wallet” AA flow).
    • Definition of done: user returns after refresh/offline and still has access to their local profile.
  • Player can onboard after 1st login and select their element, enter location details and user info
    • Element selection: Water/Earth/Fire/Air (affects creature seed + starter ability).
    • Location details: simple “home biome” label + optional geolocation (permissioned).
    • Creature is generated based on element selected and local environment data
    • Definition of done: onboarding is a state machine with explicit steps and can be resumed.
  • Player can generate creature based on their selected element and their local environment to add to their deck
    • Generation inputs: element + biome + plant type (or placeholder plant tag in V1).
    • Output: a CreatureCard (name, description, traits, signature move, starter stats).
    • V1 implementation: curated seed pack or stub generator; add LLM later behind an interface.
  • Player can nurture creature with resources earned from plant care helping them grow and gain more abilities in gameplay
    • Resource: Energy (and/or small set of materials) earned from care events.
    • Nurture action: spend energy to increase XP / stats; show immediate feedback (progress bar, animation, toast).
    • Definition of done: the creature’s state changes are persisted locally and reflected in gameplay tokens/abilities.
  • Players can evolve creature once they have enough XP and unlock new capabilities and visually have a more developed and grown creature
    • Evolution: XP threshold gates a new stage with:
    • upgraded stats
    • optional new “card frame”
    • new signature move text
    • V1 visual: swap sprite/image + stage label; 3D model later.
    • Definition of done: evolution is an explicit action, not automatic; player feels agency.
  • Player can select plant in their local environment to care for adding it to their inventory with details around the plant type, location, and initial health
    • Add plant: camera capture or upload + manual name tag.
    • Plant profile fields: species (verified or unverified), nickname, location tag, first photo timestamp.
    • Initial health: simple 0–100 score (stubbed is fine) plus “notes” field.
  • Player can nurture plants added to their inventory taking daily photos to earn resources for their creature
    • Care event: daily photo + quick checklist (watered / pruned / observed / cleaned).
    • Streak: tracks consecutive care days; decays softly (no harsh resets).
    • Reward: energy delta + occasional badge/“ether fragment”.
    • Offline: care events queue locally and can sync/attest later.
  • Player can start game in the play tab in augmented reality where they select between tic tac toe, ludo, and mancala and then play with a local peer who joins the game while also selecting their creature to act as their game asset
    • V1 scope priority: Tic-Tac-Toe (non-AR baseline) + AR mode if available.
    • Game session includes:
      • selected creatures (player tokens)
      • ruleset + turn state
      • win/draw detection
    • Local peer options:
      • “pass-and-play” on one device for V1
      • later: WebRTC / GUN / WebSocket session sync
  • Player can join game started by another player and select the creature to use
    • V1: second player joins on same device and chooses from local deck (or guest deck).
    • Definition of done: joining enforces creature selection before first move.
  • Player in an active game can make game move when it’s their turn
    • Turn enforcement is handled in the game state machine.
    • Moves are validated by a pure rules engine (easy to test).
  • Player who completes game can claim their game reward based on the result
    • Reward rule: win/draw/loss yields energy and/or a badge (tunable).
    • Definition of done: reward is recorded in local event log and reflected in Deck energy.
  • Player can publish and remix UGC (creature packs, shrine challenges, and game variants) with clear ownership metadata
    • UGC remains local-first by default, then can be shared through AT Protocol records and content-addressed storage.
    • Definition of done: each published item has a content hash, creator identity reference, and moderation status.
  • Community can promote UGC into canonized world content through transparent proof-based rules
    • Canonization is based on attestations and community signals, not opaque admin-only overrides.
    • Definition of done: a public “canon set” can be reproduced from attested events and onchain registry state.

Outputs​

  • Fully functional and usable PWA able to be deployed
    • Installable (manifest + icons) and offline-capable (service worker + caching).
    • Local-first persistence for Player/Plant/Creature/GameHistory (Dexie/IndexedDB).
    • “Always works” mode even without AR, wallets, or external APIs.
    • UI baseline matches provided comps:
      • Clean, airy layouts with generous whitespace
      • Rounded cards and modals (soft, friendly tone)
      • Clear primary CTA styling (filled) vs secondary (outlined)
      • Persistent bottom navigation (Deck / Garden / Profile) for fast mode switching
  • Semi-integrated with Green Goods protocol for reporting plant care
    • V1: define the data model and a stubbed “report” interface.
    • Phase 2: submit real attestations / onchain actions via the Green Goods integration when ready.
  • README documentation outlining core aspects
    • What the core loop is and how to demo it.
    • Architecture overview (ECS-ish data model + XState machines).
    • Clear “future seams” list (PlantID proxy, EAS, tokenbound, multiplayer).
  • UGC and autonomous world framework documented
    • Defines what data stays local, what gets attested, and what is promoted to autonomous world state.
    • Includes governance, moderation, and youth-safety policies for user-generated and agent-generated content.

Activities​

  1. Craft the plan
    1. Lock the V1 proof outcomes + definition of done for each.
    2. Decide what is “real” vs “stubbed” for the demo (PlantID, AR, onchain).
  2. Build during WEFA Studio Session
    1. Pair programming + role split:
      1. one agent: flows + state machines
      2. one agent: UI screens + styling
      3. one agent: creature content pack (JSON cards)
  3. Refine from session feedback
    1. Fix flow confusion, polish onboarding copy, tune rewards.
    2. Add basic tests for rule engine + state transitions.
  4. Deliver polished released version
    1. Deploy to Vercel, verify installability/offline behavior, and record a demo walkthrough video.
  5. Establish UGC and autonomous world growth track
    1. Ship UGC publish/remix schema and moderation states.
    2. Define canonical promotion flow (attestation-backed) and autonomous world registry integration.

Inputs​

Story & Narrative Inspiration​

  • Avatar Last Airbender - Element affinity as identity/philosophy, not just “damage type.”
  • Pokemon - Care → bond → growth → evolution loop.
  • X Men - Abilities as responsibility; powers emerge from identity.
  • Yugi-Oh - Creatures as cards (metadata + effects) and deck-building identity.
  • Dragon Ball - Training arcs and transformation/evolution milestones.
  • Cyberchase - Playful learning through puzzles/strategy games.
  • Arthur - Community warmth and approachable everyday storytelling.

Game Design Foundations​

  • …
  • …
  • …

Creature Design Foundation​

  • Arcane - Stylish silhouettes, readable shapes, and expressive “power vibes.”
  • Studio Ghibli - Warmth, nature reverence, creatures that feel alive and kind.

Base Creatures (Massiah)​

  • …
  • …

Guiding Philosophies​

  • Octalysis Framework - Map each V1 feature to a motivation drive (meaning, progress, creativity, social, ownership).
  • Local & Privacy 1st - Offline-first by default; sharing/attesting is opt-in and minimal.
  • Entity Component System - Plants/Creatures/Games are entities with composable components; systems update them over time.
  • User Generated Content - Creature cards, lore snippets, and future user-made games as first-class content.

Folder Structure​

  • packages
    • app
      • public - PWA manifest, icons, and static assets (starter creature art, UI images).
      • src
        • tests - Unit tests for rules engines and state machines (fast, deterministic).
        • i18n - Localization scaffolding for future (and for Inland Empire + global expansion).
        • components - Reusable UI components (AppBar, DeckCard, PlantTile, CreatureCard, etc.).
        • routes - Route definitions + guards (auth/onboarding gating).
        • hooks - Data + machine hooks (useOnboarding, usePlantCare, useCreatureCare, useGameSession).
        • modules - Domain modules (plants, creatures, rewards, games) and service interfaces (PlantVerifier, Generator).
        • machines (XState)
          • onboardingMachine
          • plantSelectionMachine
          • plantCareMachine
          • creatureGeneratorMachine
          • creatureCareMachine
          • creatureEvolveMachine
          • ticTacToeMachine (and future ludo/mancala machines)
        • stores - Zustand stores for view-level state; keep domain truth in DB + machines.
        • types - Zod schemas + TS types for entities, components, events.
        • utils - Helpers (date/time, geo utilities, caching, feature detection).
        • views - Page-level screens (Login, Onboard, Deck, Play, Profile).
        • index.css - Tailwind base + design tokens.
        • App.tsx - App shell, providers, layout.
        • main.tsx - Entry point + hydration.
        • router.tsx - Router configuration
        • config.ts - Environment flags, feature toggles (AR enabled, PlantID mode, analytics on/off).
      • .lighthouserc.json
      • index.html
      • package.json
      • tsconfig.json
      • vite.config.ts
      • vitest.cofig.ts
    • contracts
      • lib
      • config
      • scripts
        • Deploy.s.sol
      • src
        • interfaces
          • IGreenGoods.sol
        • account
          • Keeper.sol
          • Plant.sol
          • Creature.sol
        • modules
          • GreenGoods.sol
        • tokens
          • Keeper.sol
          • Plant.sol
          • Creature.sol
          • Game.sol
          • WEFA.sol
      • test
      • .solhint.json
      • remappings.txt
      • foundry.toml
  • scripts
    • setup.js - Dev bootstrap and environment setup.
    • deploy-contracts.ts - Optional scripts for deploying contracts and syncing addresses to app config.
  • e2e - Playwright end-to-end tests (happy paths: onboard → add plant → play game).
  • .claude
  • .devcontainer
  • .github
    • workflows
    • ISSUE_TEMPLATE
  • gitignore
  • package.json
  • coderabbit.yaml
  • .browserlistrc
  • .oxlintrc.json
  • biome.json
  • Claude.md
  • LICENSE
  • tsconfig.json
  • playwright.config.ts
  • README

App Views​

  • Login - Choose passkey or wallet; show “local-first” promise and privacy stance.
  • Onboard - Select element + home biome; optional location permission; create first creature seed.
  • Deck - Inventory hub: Energy, Plants list, Creatures list, quick actions (Care / Nurture / Evolve).
    • Inventory hub: Energy, Plants list, Creatures list, quick actions (Care / Nurture / Evolve).
    • UI reference: “Energy header + segmented inventory”
      • Top bar shows ENERGY count prominently
      • Segmented tabs for Plants / Creatures (fast switching without leaving screen)
      • List items are wide cards with: Name + category chip + thumbnail image
      • Filter icon in header area for future sorting (by type, streak, element, health)
  • Play - Choose game + choose creature(s) + launch non-AR or AR session.
    • Choose game + choose creature(s) + launch non-AR or AR session.
    • AR camera view where creatures “exist” in the player’s real environment.
    • UI reference: AR board is a simple grid overlay placed on the ground plane
      • Minimal UI chrome during play so AR stays immersive
      • Creatures rendered as the “pieces” (reinforces the collectible/deck value)
      • Top snackbar/toast for rewards & milestones (non-blocking)
      • Reward modal overlays for nurture events (Share / View)
  • Profile - Stats (streaks, games played), settings (privacy, export), and future identity connectors.

App Components​

  • Player Deck
  • Game Canvas
  • AppBar
    • Navigation + install status + sync/connection indicators.
    • UI reference: “Energy header” style
      • Compact top header with a badge/metric (ENERGY) and an icon
  • BottomTabBar
    • Persistent bottom navigation used across Deck / Garden / Profile
    • Keeps AR flows accessible without deep navigation stacks
  • ChoiceCardGrid (Head to Head Competition)
    • Two-up onboarding cards (e.g., Vegetables vs Fruits)
    • Used for quick preference capture with playful micro-illustrations
  • SegmentedTabs
    • Plants / Creatures toggle within Deck (no route change required)
  • PlantTile / PlantRowCard
    • Name + category chip + image thumbnail
    • Color-tinted background per row to make scanning easy
  • RewardToast / Snackbar
    • Non-blocking top banner for quick rewards (“Congrats! …”)
    • Used in AR without forcing modals
  • RewardModal
    • Large image preview + reward line + dual CTAs (Share / View)
    • Used after nurture actions to close the loop and encourage sharing
  • PlantCard / PlantDetail
    • Plant hero image on gradient background
    • Nurture Flow
  • CreatureCard / CreatureDetail
    • Creature hero image on gradient background
    • Tabs: Nurture / Evolution
  • CreatureEvolutionPanel
    • Evolve CTA + element chip (e.g., Water)
    • Before/after preview showing current stage → next stage with level labels

App Gameplay​

  • Tic Tac Toe
    • First “AR grid” primitive; deterministic rules; fast feedback loop.
    • UI reference: board is rendered as a bright ground-plane grid (high contrast)
    • Creatures appear as AR pieces/avatars near the board to reinforce deck value
  • Ludo
    • Phase 2 game: longer sessions, social play, more reward hooks.
    • Should reuse the same “board placement + creature pieces” AR pattern
  • Mancala
    • Phase 2 game: strategic, culturally resonant, supports learning.
    • Should reuse the same “board placement + creature pieces” AR pattern
  • Chess

Coding Agents​

  • Claude Code - Best for architecture, refactors, and translating spec → code modules.
  • Codex - Best for rapid code scaffolding, tests, and repetitive implementation tasks.

Agents Skills​

  • Frontend Design
  • Webapp Testing
  • React
  • Docker
  • WebXR
  • Security

Tech Pillars​

  • Augmented Reality - WebXR-based “garden mode” and board placement; always keep a non-AR fallback.
  • Ethereum - Phase 2+: attestations (EAS), tokenbound accounts, marketplace primitives.
  • Autonomous World - Phase 2+: canonical public state for shrines, tournaments, and world progression.
  • IoT - Phase 2+: NFC/Bluetooth “shrines” and plant sensors as optional enhancements.
  • Artificial Intelligence - Plant identification/health signals + creature generation (seed pack → cloud → on-device).

User Interface​

  • React - Component and view level routing system.
  • Tailwind - Fast iteration on UI + consistency across screens.
  • Three.js - 3D rendering foundation and WebXR integration.
  • React Three Fiber - React renderer for Three.js to keep 3D work in the same mental model as UI.
  • XR - @react-three/xr for entering AR and managing XR session primitives.
  • React Router - App route gating/system and deep-linkable screens.

State/Data Management​

  • GUN - Phase 2+: realtime p2p sync for shared play and shared spaces.
  • XState - Flow control and deterministic transitions; great for testing and clarity.
  • Zustand - Lightweight UI state and view caches.
  • Uurql - GraphQL client (optional; useful when Green Goods or other APIs are integrated).
  • Dexie - Local IndexedDB wrapper for persistence of entities and event logs.

Generated Content​

  • Meshy - 3D Creature generation based on based set of elemental creatures

Data​

  • EAS - Phase 2+: milestone attestations (first plant, 7-day streak, tournament win).
  • Zod - Runtime validation for all entity/component schemas and API boundaries.
  • IPFS - Phase 2+: content-addressed storage for creature art/models and UGC.
  • AT Protocol - Phase 2+: identity-linked social records for discovery, sharing, and UGC references.
  • Autonomous world registry - Phase 2+: onchain canon set and season state pointers.

APIs​

  • Pimlico - Account abstraction infrastructure (bundler/paymaster) for “thin wallet” UX later.
  • Viem - Type-safe EVM tooling for reads/writes and contract interactions.
  • Pinata - IPFS pinning and content management for media assets.
  • PlantID - Plant identification/health API; integrate via server-side proxy (never expose API keys in the client).

Web APIs​

  • Web Fetch
  • Vibration
  • Background Sync
  • Geolocation
  • Push
  • Notifications
  • Temporal
  • WebXR
  • WebRTC
  • WebCrypto API
  • Service Worker
  • Badging API
  • IndexedBD
  • Fullscreen API
  • Screen Orientation
  • Web Audio API
  • Screen Wake Lock
  • WebAuth

Development Tools​

  • Bun
  • Vite
  • Vitest
  • React Testing Library
  • Mock Server Library
  • Playwright
  • Workbox
  • Biome
  • 0xLint

Deployment​

  • Github Actions - CI for lint/test/build and deploy workflows.
  • Vercel - Deploy the PWA + host serverless proxies (PlantID) and small APIs.

Monitoring​

  • Posthog - Product analytics (privacy-conscious configuration; opt-in where possible).
  • Dune Analytics - onchain analytics for attestations/transactions.

Media​

  • WEFA Character Lineup - Use as canonical reference for element identity, silhouettes, and personality cues.

Resources​