Goal Cracker - Recursive AI Strategy Engine

A strategic planning engine that fractures ambiguous goals into atomic, actionable blueprints. Features infinite recursive drill-downs and non-hallucinating structured outputs.

Project Overview

Details and technologies

Full Stack AI Application

Goal Cracker is not just another chatbot; it is a Strategic AI Planning Engine designed to cure the paralysis of big ambitions. Unlike standard LLMs that offer vague, hallucinated advice, Goal Cracker enforces strict JSON-structured reasoning to fracture complex goals into 5 specific, actionable steps. Users can 'drill down' infinitely into any step, creating a deep recursive tree of tasks using a fractal planning approach. With a visual Mind Map for navigation, exportable blueprints, and a multi-agent 'War Room' (switching between Llama 3.3 and Mixtral), it allows users to audit their strategy from the macro vision down to the micro execution, ensuring they always know exactly where they stand in relation to their actual goal.

Technologies

Next.js 16TypeScriptFastAPI (Python)PostgreSQLDockerGroq APITailwind CSS v4Framer MotionBetter AuthSQLAlchemyRechartsZustand

Key Features

•Infinite Recursive Drill-Down (Fractal Planning)

•Multi-Agent 'War Room' (Hot-swap Llama 3.3/Mixtral)

•Interactive Mind Map with Zoom, Pan, & Filters

•Visual Complexity Mapping & Difficulty Charts

•Real-Time Streaming with Hybrid JSON/Text Parsing

•Non-Hallucinating Structured Output Enforcement

•Branching Timelines (Version Control for Ideas)

•Secure Authentication (Google/Email via Better Auth)

•Visual Data Export (SVG, PNG, PDF, JSON, Markdown)

•Dynamic Slogans & Featured Examples Engine

Project Screenshots

Scroll through to see some pages of the application

1 / 5

Landing & Dynamic Slogans

Landing

The entry point featuring dynamic, rotating slogans and featured examples to spark user ideation.

Landing & Dynamic Slogans

Landing

The entry point featuring dynamic, rotating slogans and featured examples to spark user ideation.

Strategy Dashboard & Breakdown

Dashboard

The main interface showing the active plan, complexity chart, and chat stream.

Mind Map Navigator

Visualization

A fullscreen recursive tree visualization of the strategy branches.

Secure Authentication

Auth

Better Auth integration supporting Google OAuth and Email/Password flows.

Transparent AI Reasoning

AI Features

Expandable logs showing the AI's internal monologue and decision process.

Loading overview...

System Architecture

Architecture Overview

Goal Cracker utilizes a decoupled client-server architecture designed for high-concurrency AI streaming. The frontend is a Next.js 16 application providing a reactive, state-heavy UI for the Mind Map and Chat, while the backend is a Python FastAPI service handling AI orchestration, recursive logic, and secure database persistence.

Interactive Client Layer

A Next.js 16 application utilizing Server Components and extensive client-side state (Zustand/Context) to manage the recursive strategy tree.

Technologies

Next.js 16TypeScriptTailwind v4Framer MotionRechartsReact Flow (Logic)

Components

Chat Stream Parser
Recursive Mind Map
Complexity Visualizer
Better Auth Client

Strategic AI Engine

FastAPI service acting as the 'Cortex', managing connections to Groq, enforcing JSON schemas, and handling rate limits.

Technologies

FastAPIPython 3.11SlowAPIPydanticHTTPX

Components

AI Orchestrator
Stream Generator
Rate Limiter
Recursive Data CRUD

Recursive Data Persistence

PostgreSQL database with a schema optimized for hierarchical conversation data and infinite branching depths.

Technologies

PostgreSQLSQLAlchemyAsyncPGAlembic

Components

User/Session Tables
Recursive Goal/Turn Nodes
JSONB Strategy Storage

Containerized Infrastructure

Fully Dockerized environment ensuring consistency between local development and production deployment on Render.

Technologies

DockerDocker ComposeRender.comGunicorn

Components

Frontend Container
Backend API Container
Managed Postgres Service

System Architecture Diagram

User

Next.js Client

FastAPI Backend

Groq AI

PostgreSQL

Better Auth

Wheel to zoom • Drag to pan • Click elements for details

100%

Admin

User

Auth

Service

Assets/Notif.

Key System Interactions

Hybrid Streaming

Backend yields raw bytes; Frontend parses partial JSON tokens in real-time to render UI components before the full response is complete.

Fractal Branching

Editing a message or drilling down creates a new 'Turn Version' or 'Child Node', forking the conversation history tree without data loss.

Model Hot-Swapping

The Controller logic allows users to switch the active LLM provider (Groq Llama/Mixtral) for any specific turn to compare reasoning styles.

Auth Synchronization

Better Auth handles session tokens, syncing user state seamlessly between Next.js middleware and FastAPI dependency injection.

Key Features

Multi-Model Reasoning

Switch between fast models for outlining and heavy reasoning models for deep strategy.

Complexity Visualization

Dynamic bar charts render the difficulty of every step generated by the AI.

Recursive Planning

Click 'Drill Down' on any step to generate a sub-plan, creating a nested strategy tree.

Hybrid Parsing

Simultaneously handles unstructured thought logs and structured JSON plans.

Implementation Details

Installation & Setup

The system is divided into client (frontend) and server (backend) components, each with its own installation process:

git clone https://github.com/YourUsername/goal-breaker.git
cd goal-breaker
# Backend Setup
cd backend && python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
# Frontend Setup
cd ../frontend && pnpm install
# Run with Docker
docker-compose up --build

Development Environment

Running the application requires starting the necessary services:

Frontend running on localhost:3000
Backend API running on localhost:8000/docs
PostgreSQL database via Docker container
Groq API Key required for AI functionality

Security Considerations

SlowAPI rate limiting on generation endpoints to prevent abuse
Better Auth for secure session management and OAuth handling
Server-side validation of all AI prompts using Pydantic models
Strict CORS configuration for production domains

Loading architecture...

Challenges & Solutions

Building this full-stack system involved several complex challenges that required innovative solutions and professional growth.

Streaming Mixed Content (JSON + Text)

Challenge:

The AI agents needed to provide a conversational response ("message") AND a structured plan ("steps") simultaneously. Waiting for the full response made the UI feel slow, but standard JSON parsers crash on incomplete strings during streaming, causing the UI to flicker or fail.

Solution:

I implemented a fault-tolerant streaming hook on the frontend using `best-effort-json-parser`. This allows the UI to "peek" into the incoming byte stream and render valid parts of the JSON (like the "Thinking" logs and partial "Steps") progressively as they arrive, creating a seamless, instant-feedback experience.

Click to see solution

Infinite Branching History

Challenge:

Unlike a linear chat, Goal Cracker allows users to edit any previous message or "drill down" into a specific step, creating a complex tree of alternate timelines and nested goals. Managing this state in a linear SQL database while keeping the UI navigational was complex.

Solution:

I designed a recursive "ChatTurn" and "TurnVersion" schema in PostgreSQL where every message links to a parent ID. On the frontend, I built a recursive "Mind Map" navigation system using React Context that rebuilds the visual tree structure from the flat array of turns fetched from the database.

Click to see solution

Multi-Agent State Management

Challenge:

Users can switch models (e.g., from Llama to Mixtral) mid-stream or for specific turns. Keeping track of which agent generated which part of the plan without race conditions or data overwrites was difficult.

Solution:

I utilized `AbortController` references mapped to specific agent/turn IDs. This ensures that if a user switches agents or stops generation, only the specific relevant network request is cancelled, and the state machine cleanly transitions to the new agent without affecting other history items.

Click to see solution

Preventing Hallucination

Challenge:

General purpose LLMs often "hallucinate" or drift into conversational fluff when asked for strict plans, breaking the application's rigid data structure requirements.

Solution:

I engineered a robust "System Prompt" layer that strictly enforces a specific JSON output schema. This is backed by a Pydantic validation layer on the backend that sanitizes inputs and outputs, ensuring the AI focuses purely on actionable, structured logic rather than creative writing.

Click to see solution

Project Outcomes

Despite these challenges, I successfully delivered a full-stack application that provides a comprehensive platform. The system now efficiently handles all core requirements while maintaining high standards of security and user experience.

100%

Core requirements met

Major challenges overcome

Key solutions developed

Loading challenges...

Code Implementation Highlights

Key code examples from this financial software project, showcasing authentication, calculations, visualizations, and data management implementations.

Future Improvements

Strategic enhancements planned for the Personal Loan Management System, designed to extend functionality and improve user experience.

Real-Time Team Collaboration

Allow multiple users to enter the same "War Room" via WebSockets to edit plans, chat with agents, and vote on strategies together in real-time.

BENEFITS

Enables remote teams and co-founders to brainstorm strategies collaboratively without version conflict.

TECHNOLOGIES

Socket.io, Redis, Yjs (CRDTs)

Calendar & Task Integration

One-click export of the generated 5-step plan directly to Google Calendar, Notion, or Jira with automatically calculated deadlines based on difficulty.

BENEFITS

Reduces the friction between planning and actual execution by putting tasks where users work.

TECHNOLOGIES

Google Calendar API, Notion API, OAuth

Voice Mode & Dictation

Implement speech-to-text (Whisper) and text-to-speech to allow users to brainstorm complex goals while walking or driving, converting rambles into structured JSON.

BENEFITS

Increases accessibility and allows for on-the-go usage where typing is not feasible.

TECHNOLOGIES

OpenAI Whisper, Web Speech API