FR3K - Universal AI Development System

███████╗██████╗ ██████╗ ██╗  ██╗
██╔════╝██╔══██╗╚════██╗██║ ██╔╝
█████╗  ██████╔╝ █████╔╝█████╔╝
██╔══╝  ██╔══██╗ ╚═══██╗██╔═██╗
██║     ██║  ██║██████╔╝██║  ██╗
╚═╝     ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝

The Most Advanced AI-Driven Development Environment Ever Created

Features • Quick Start • Dashboard • Documentation • Philosophy

🚀 What is FR3K?

FR3K is a Universal AI Development System that combines:

• 🎯 TAC (Tactical Agentic Coding): 8-tactic methodology for systematic development
• 🧪 Fabric Patterns: 220+ AI patterns for prompts, analysis, and code generation
• ♻️ APEX: Adaptive Pattern EXecution with self-improving test loop
• 📺 Adaptive Dashboard: AI-driven tmux environment that adapts to your workflow
• 🔊 Voice Announcements: Profane and entertaining audio feedback
• 📚 Knowledge Base: 704+ curated files of development wisdom
• 🧠 MCP Integration: Memory management, task tracking, intelligent coordination

Philosophy

Adaptive • Intelligent • Self-Improving • Entertaining

FR3K doesn't just monitor your development—it actively participates, learns from failures, celebrates wins, and provides profane commentary that makes coding more fun.

✨ Features

🎮 One-Command Launch

cc  # That's it. Claude Code + Adaptive Dashboard + AI Engine + Voice

📊 Adaptive Dashboard

• 44% LEFT: Claude Code interface
• 26% MIDDLE: Real-time metrics + workflow context
• 30% RIGHT: Self-improvement cycle (swaps for critical events)
• Dynamic Panes: Logo animations, breakthrough/failure notifications
• Auto-Adapts: To backend, frontend, fullstack, devops, testing, ML workflows

🧠 AI Decision Engine

• Analyzes context every 5 seconds
• Priority scoring (0-10) for content relevance
• Automatically shows what matters NOW
• Detects breakthroughs (>95% success)
• Warns on failure spikes (3+ in 5min)

🔊 Voice Announcements

• Google TTS: Female voice, 1.6x speed
• Profane Anecdotes: Every 2-3 minutes when idle
• Breakthrough Celebrations: "Holy shit, 96% success rate!"
• Failure Warnings: "Fuck me, we've got a spike!"
• Pulsing Logo: 11-color FR3K ASCII animation

♻️ APEX Self-Improvement

• Continuous test-improve-test loop
• Learns from failures automatically
• Tracks learning velocity
• Applies improvement strategies
• Measures progress over iterations

📚 Massive Knowledge Base

• Fabric: 220+ AI patterns
• TAC: Complete methodology docs
• Tmux: Layout strategies for all workflows
• Behemoth: Crypto trading patterns
• Plus: Maritime law, Freemasonry, Symbols, and more

🎯 Smart Workflow Detection

Auto-detects and adapts to:

• Backend API (Go, Rust, Node, Python)
• Frontend (React, Next.js, Vue)
• Full-Stack (Monorepos)
• DevOps (Terraform, Kubernetes)
• Testing (Jest, pytest, Cargo)
• Data Science (Jupyter, Pandas, ML)
• Documentation (Markdown with preview)

🚀 Quick Start

Installation

# Clone FR3K
git clone https://github.com/fr3k/fr3k.git ~/fr3k/fr3k
cd ~/fr3k/fr3k

# Run installation (auto-installs dependencies)
npx ./cli/index.js init

# Or use the quick command (after setup)
cc

Dependencies will be installed automatically:

• tmux, jq, bc, python3 (via apt)
• gtts, mpg123, ffmpeg (for voice - optional)

Platform Support

Linux/macOS: Full dashboard with tmux Android (Termux): Simplified mode without dashboard (graceful fallback)

• Knowledge base access still works
• CLI commands available
• Install tmux for full features: pkg install tmux

Setup Aliases

# Add FR3K to your shell (auto-added during init)
echo '[ -f ~/.bashrc_fr3k ] && source ~/.bashrc_fr3k' >> ~/.bashrc
source ~/.bashrc

Launch Options

# Quick launch (recommended)
cc                      # Claude Code + Full Dashboard

# Full init with analysis
npx fr3k init           # Analyzes codebase, launches dashboard

# Dashboard only
dashboard              # or: dash, adaptive

# Smart tmux (auto-detects workflow)
smart-tmux code        # Development layout
smart-tmux test        # Testing layout
smart-tmux debug       # Debugging layout
smart-tmux review      # Code review layout

📺 Adaptive Dashboard

Layout

┌─────────────────────────────────────────────────────────────┐
│  FR3K ADAPTIVE DASHBOARD - The Ultimate Dev Environment    │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────┬──────────────┬───────────────────────┐  │
│  │              │  MIDDLE-TOP  │                       │  │
│  │              │   (26×40%)   │                       │  │
│  │              │              │                       │  │
│  │    LEFT      │  Metrics:    │       RIGHT           │  │
│  │   (44%)      │  - APEX      │      (30%)            │  │
│  │              │  - Git       │                       │  │
│  │  Claude      │  - System    │  Self-Improvement     │  │
│  │  Code        │              │  Cycle                │  │
│  │  Interface   ├──────────────┤  (default)            │  │
│  │              │ MIDDLE-BTM   │                       │  │
│  │              │  (26×60%)    │  OR                   │  │
│  │              │              │                       │  │
│  │              │  Context:    │  Pertinent Info       │  │
│  │              │  - Workflow  │  (swaps dynamically)  │  │
│  │              │  - Files     │                       │  │
│  │              │  - Services  │                       │  │
│  └──────────────┴──────────────┴───────────────────────┘  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Dynamic Content

RIGHT Pane (Self-Improvement - Default):

• Current APEX metrics
• Recent improvements
• Learning trends
• Opportunities

Swaps to (when critical):

• Breakthrough notifications (>95% success)
• Failure spike warnings (3+ failures)
• Codebase analysis (during init)
• Critical alerts

MIDDLE Panes:

• TOP: Real-time metrics (APEX, Git, System)
• BOTTOM: Workflow context (files, services, focus)

Adaptive Intelligence

The dashboard automatically adapts based on:

• Current workflow (detected from files/structure)
• Project context (git branch, running services)
• Event triggers (breakthroughs, failures)
• Time-based relevance (what matters NOW)

🎯 Commands Reference

Core Commands

cc                      # Launch Claude Code dashboard
fr3k init [path]        # Initialize FR3K for project
fr3k dashboard          # Launch adaptive dashboard
fr3k kb <query>         # Search knowledge base
fr3k help               # Show help

APEX Commands

apex-start              # Start self-improvement loop
apex-stop               # Stop loop
apex-stats              # View metrics (JSON)

Workflow Commands

smart-tmux code         # Development layout
smart-tmux test         # Testing layout
smart-tmux debug        # Debugging layout
smart-tmux review       # Code review layout
smart-tmux deploy       # DevOps layout
smart-tmux monitor      # Monitoring layout
smart-tmux docs         # Documentation layout

Knowledge Base

kb <query>              # Search all KB files
fabric [pattern]        # View Fabric pattern

Voice & Monitoring

say <message>           # Queue voice announcement
fstatus                 # Show FR3K process status
fhelp                   # Show all commands

Tmux Management

tl                      # List sessions
ta <name>               # Attach to session
tn <name>               # New session
tk <name>               # Kill session
tcc                     # Attach to Claude session

📋 TAC Methodology

FR3K integrates Tactical Agentic Coding - an 8-tactic systematic approach:

1. Read the Actual Code: Never assume, always verify
2. Verify Before Claiming: Check imports/APIs exist
3. Test What You Build: Run code, ensure it works
4. Think Before Coding (ADW): Analyze → Design → Write
5. Simple First: Start simple, add complexity only when needed
6. Learn From Errors: Store failures in memory
7. Validate Relentlessly: Continuous testing via APEX
8. Iterate to Excellence: Self-improvement loop

ADW Workflow

For complex tasks:

ANALYZE  → Understand requirements, read code, identify patterns
DESIGN   → Plan architecture, choose patterns, outline approach
WRITE    → Implement with tests, validate as you go, iterate

🧪 Fabric Patterns

Access 220+ AI patterns for:

• Code generation and improvement
• Prompt engineering
• Architecture design
• Test strategy
• Security analysis
• Documentation
• Code review
• Debugging strategies

Located: kb/fabric/

Usage: fabric <pattern-name>

♻️ APEX Self-Improvement

Adaptive Pattern EXecution runs continuously:

How It Works

1. Test: Run parallel validation (4 workflows × 3 agents)
2. Analyze: Extract failure patterns
3. Strategize: Apply improvement techniques
4. Measure: Track success rate & velocity
5. Learn: Store patterns in memory
6. Celebrate: Voice announcements on milestones

Metrics

• Success Rate: % of tests passing
• Learning Velocity: Rate of improvement per iteration
• Milestones: Auto-celebrated at 90%, 95% thresholds

View Status

apex-stats  # View metrics JSON
# Check RIGHT pane in dashboard for live updates

🔊 Voice System

Features

• Google TTS: Female voice, 1.6x speed
• Profane: Liberal use of "fuck", "shit", "damn"
• Entertaining: Developer humor and insights
• Adaptive: Announces events as they happen

Examples

Idle Anecdote:

"Fun fucking fact: There are more possible chess games than atoms in the universe. And yet developers still can't center a fucking div."

Breakthrough:

"Holy shit! We just hit 96.7 percent success rate! This is a fucking breakthrough moment!"

Failure:

"Fuck me, we've got a failure spike! 5 tests just ate shit. Time to debug this clusterfuck!"

Custom Announcements

say "Your custom fucking message here!"

Disable Voice

Edit scripts/dashboards/engine/voice-announcer.sh:

TTS_CMD="echo"  # Silent mode

📚 Knowledge Base

Contents

• 704+ files organized by category
• Fabric: 220+ AI patterns
• TAC: Complete methodology
• Tmux: Layout strategies for 11 workflows
• Behemoth: Crypto trading patterns
• Maritime Law: Legal templates
• Freemasonry: Symbols and meanings
• And more

Search

kb "testing strategies"         # Search all files
fabric create_coding_prompt      # View specific pattern

Structure

kb/
├── fabric/              # 220+ AI patterns
├── tac/                 # TAC methodology
├── tmux/                # Tmux layouts & strategies
├── claude-code/         # Dashboard integration docs
├── behemoth/            # Crypto patterns
└── ...                  # Specialized knowledge

🛠️ Architecture

Components

1. Main Orchestrator: scripts/dashboards/claude-code-adaptive.sh

   • Creates tmux layout
   • Launches background processes
   • Sets theme

2. AI Decision Engine: scripts/dashboards/engine/decision-engine.py

   • Analyzes context every 5s
   • Decides pane content
   • Queues voice announcements

3. Voice Announcer: scripts/dashboards/engine/voice-announcer.sh

   • TTS with profanity
   • Pulsing logo animation
   • Monitors announcement queue

4. Event Monitor: scripts/dashboards/engine/event-monitor.sh

   • Detects breakthroughs
   • Watches for failures
   • Creates notification panes

5. Pane Controllers: scripts/dashboards/panes/adaptive/

   • Self-improvement display
   • Metrics display
   • Workflow context
   • Test results

Communication

• State: engine/dashboard-state.json
• Commands: /tmp/claude-dashboard-commands (FIFO)
• PIDs: /tmp/claude-dashboard-*.pid
• Voice Queue: engine/next-announcement.txt

Resource Usage

• Total RAM: ~60MB
• CPU: <5% average
• Network: None (except TTS generation)
• Disk: <10KB state files

🎨 Customization

Change Voice Speed

scripts/dashboards/engine/voice-announcer.sh line 40:

ffplay -af "atempo=1.8" $TMP_FILE  # 1.8x instead of 1.6x

Change Announcement Interval

scripts/dashboards/engine/decision-engine.py line 67:

self.min_interval = 180  # 3 minutes instead of 2

Add Custom Anecdotes

scripts/dashboards/engine/decision-engine.py ~line 140:

anecdotes = [
    "Your custom profane anecdote here!",
]

Adjust Pane Sizes

scripts/dashboards/claude-code-adaptive.sh lines 40-50:

tmux resize-pane -t "$SESSION_NAME:0.1" -x 35%  # RIGHT width

Change Color Scheme

scripts/dashboards/claude-code-adaptive.sh lines 20-24:

tmux set -g pane-border-style "fg=colour57"           # Purple
tmux set -g pane-active-border-style "fg=colour99"    # Bright purple
tmux set -g status-style "bg=colour53,fg=colour213"   # Status bar

🐛 Troubleshooting

tmux not found?

# Linux
sudo apt install tmux

# Android (Termux)
pkg install tmux

# macOS
brew install tmux

Note: On Android without tmux, FR3K runs in simplified mode with KB/CLI access.

Dashboard fails to launch?

# Check tmux version (requires 2.1+)
tmux -V

# Terminal too small?
# Resize to at least 120×30

# Test tmux
tmux new-session -s test

# Check config
mv ~/.tmux.conf ~/.tmux.conf.bak

# Try manual launch
bash ~/fr3k/fr3k/scripts/dashboards/claude-code-adaptive.sh

No voice output?

# Install TTS
pip install gtts
sudo apt install mpg123 ffmpeg

# Test
source ~/fr3k/streamlit_venv/bin/activate
echo "Test" | gtts-cli -l en - | mpg123 -

Dashboard not updating?

# Restart decision engine
kill $(cat /tmp/claude-dashboard-engine.pid)
~/fr3k/fr3k/scripts/dashboards/engine/decision-engine.py &

Panes empty or frozen?

# Check processes
fstatus

# Restart dashboard
tkall  # Kill all tmux
cc     # Relaunch

Logo not animating?

# Install ASCII art tools (optional)
sudo apt install figlet toilet lolcat

📖 Documentation

• Complete Architecture: kb/claude-code/adaptive-dashboard-architecture.md
• Integration Guide: kb/claude-code/adaptive-dashboard-integration.md
• System Prompts: .claude/CLAUDE.md
• Tmux Research: kb/tmux/layout_strategies.md
• Dynamic Patterns: kb/tmux/dynamic_launcher_pattern.md
• Launch Guide: ADAPTIVE-DASHBOARD-READY.md

🎯 Philosophy

FR3K embodies these principles:

Adaptive, Not Static

Changes based on what matters NOW, not hard-coded displays.

Intelligent, Not Dumb

AI decides content using priority scoring, not rigid rules.

Self-Improving, Not Fixed

Learns from failures automatically via APEX cycle.

Entertaining, Not Boring

Profane voice adds personality to development.

Practical, Not Fancy

Shows actionable info, not vanity metrics.

Autonomous, Not Manual

Runs independently with minimal user input.

The dashboard is an AI co-pilot that GIVES A FUCK about your code.

🤝 Contributing

Contributions welcome! Please feel free to submit a Pull Request.

Areas for Contribution

• Additional Fabric patterns
• More tmux layouts
• Voice announcement variations
• Workflow detection improvements
• Language-specific integrations
• Documentation improvements

📜 License

MIT License - see LICENSE for details.

🙏 Acknowledgments

• TAC Methodology: Systematic agentic coding approach
• Fabric Project: Comprehensive pattern library
• tmux: Terminal multiplexer foundation
• Claude: AI capabilities
• Google TTS: Voice synthesis

🔗 Links

• Documentation: Full docs in kb/ directory
• Issues: Report bugs and request features
• Discussions: Share your FR3K setup

Built with 🤖 and profanity by the FR3K team

Remember: Simple + Verified > Complex + Assumed

Type cc to get started 🚀