The speaker scaled from $30k to $180k/month in 5-6 months with 597 active subscribers, selling a website template built on GoHighLevel.

2026 02 26 he makes 178000 per month selling one website template

Demonstrates rapid growth potential with a focused SaaS offering.

Analyze the GoHighLevel website template offering and identify potential areas for differentiation or improvement in our own product.


The speaker's initial strategy involved cold calling to sell websites and reviews, eventually landing a dog groomer as their first client who is still a customer.

Highlights the importance of direct sales and persistence in the early stages of business development.

Implement a cold outreach strategy targeting a specific niche to acquire initial customers and validate our product offering.


The speaker emphasizes the importance of taking action and avoiding overthinking, even if the initial product or service is imperfect.

Reinforces the need for rapid iteration and learning from real-world experience.

Prioritize launching a minimum viable product (MVP) and gathering user feedback to guide future development efforts.


The speaker uses a VA and AI (ChatGPT and GoHighLevel integration) to automate website creation based on an onboarding form filled out by the client.

Demonstrates a scalable approach to service delivery using AI and automation.

Explore integrating AI tools like ChatGPT with our platform to automate content creation, customer support, or other repetitive tasks.


The speaker's partner, Mike, is described as a "hyper intelligent backend dude" and "nerd" who is responsible for the AI-powered website creation system.

Highlights the importance of having a strong technical co-founder or team member to develop and maintain AI-driven solutions.

Assess our team's technical capabilities and identify any gaps in AI development expertise.


The speaker initially sold websites for $97/month and later scaled to $297/month, focusing on a single offer and avatar.

Demonstrates the viability of a low-ticket SaaS model for rapid customer acquisition and scaling.

Evaluate our pricing strategy and consider offering a lower-priced entry-level plan to attract a wider customer base.


The speaker emphasizes the importance of setting realistic expectations with clients and positioning the website as a system rather than a lead generation tool.

Highlights the need for clear communication and transparency in sales and marketing.

Refine our sales messaging to clearly articulate the value proposition of our product and avoid overpromising results.


The speaker advises against spending money on ads until a solid sales process and messaging have been developed through cold calling.

Emphasizes the importance of mastering the fundamentals of sales before investing in paid advertising.

Delay launching paid advertising campaigns until we have a proven sales process and a clear understanding of our target audience.


The speaker used Google Maps and his iPhone to find leads for cold calling in the early stages of his business.

Demonstrates that simple, low-cost methods can be effective for lead generation in the beginning.

Explore alternative lead generation methods, such as scraping Google Maps or using LinkedIn Sales Navigator, to supplement our existing strategies.


The speaker experienced 33 no-shows in a row before tweaking his ads and switching to a landing page with a booking funnel.

Highlights the importance of continuously testing and optimizing marketing campaigns to improve conversion rates.

Implement A/B testing on our landing pages and ad creatives to identify elements that improve lead quality and conversion rates.


The speaker initially used Facebook lead form ads but found them ineffective due to the inability to disqualify leads.

Illustrates the importance of selecting the right advertising platform and ad format for the target audience and business goals.

Re-evaluate our advertising channels and ad formats to ensure they are aligned with our lead qualification criteria and conversion goals.


The speaker emphasizes focusing on one channel, one product, and one avatar to reach a million dollars a year before diversifying.

Reinforces the importance of focus and specialization in the early stages of business development.

Maintain a laser focus on our core product offering and target audience until we achieve significant traction and revenue growth.


The speaker only started upselling into ads and AI-related services after reaching $150,000/month in revenue with over 400 clients.

Suggests a phased approach to product expansion and upselling, starting with a core offering and gradually adding complementary services.

Develop a roadmap for future product expansions and upsells, but prioritize scaling our core offering first.


Claude Code is an agent that can be used in a command line interface to control a computer through natural language.

2026 02 26 how i use obsidian claude code to run my life

Enables automation of tasks previously requiring manual interaction with the computer.

Investigate Claude Code's capabilities and potential applications for automating tasks.


Passing files as context to Claude Code saves time and improves the quality of responses by avoiding repeated explanations.

Increases efficiency and effectiveness of AI interactions.

Develop a system for organizing and passing relevant context files to AI agents.


Obsidian CLI allows Cloud Code to access and understand the interrelationships between files in an Obsidian vault.

Enables AI to surface patterns and insights that would be difficult or impossible for humans to identify.

Explore Obsidian CLI and its integration with AI agents for knowledge discovery and pattern recognition.


Vin uses custom commands within Obsidian to automate tasks such as loading full context, performing morning reviews, and challenging his own beliefs.

Demonstrates the power of combining personal knowledge management with AI automation.

Analyze Vin's custom commands and adapt them for personal use, focusing on context loading and belief challenging.


The 'Ghost' command builds a voice profile from the vault and answers questions in that voice, evaluating the fidelity.

Enables personalized AI responses that reflect the user's unique perspective and style.

Investigate methods for creating voice profiles from text data and evaluating the fidelity of AI-generated responses.


The 'Challenge' command pressure tests current beliefs using the vault's own history, finding contradictions and shifts in thinking.

Promotes intellectual growth and reduces bias by challenging existing viewpoints.

Implement a system for identifying contradictions and shifts in thinking within a knowledge base.


The 'Emerge' command surfaces ideas implied but never stated in the vault, identifying conclusions from scattered premises and unnamed patterns.

Facilitates the discovery of novel insights and connections within a knowledge base.

Develop algorithms for identifying implied ideas and patterns within unstructured text data.


The 'Drift' command compares stated intentions against actual behavior over 30-60 days, surfacing what the user is avoiding.

Provides valuable self-awareness and helps users identify and address areas of avoidance.

Explore methods for tracking intentions and behavior over time and identifying discrepancies.


The 'Deep' command performs a 30-day vault scan with cross-domain pattern detection and graph analysis to generate ideas across all domains.

Generates a wide range of ideas and insights by leveraging the interconnectedness of information across different domains.

Develop algorithms for cross-domain pattern detection and graph analysis to generate novel ideas.


The 'Trace' command tracks how an idea has evolved over time across the vault.

Provides a historical perspective on the development of ideas and facilitates deeper understanding.

Implement a system for tracking the evolution of ideas over time within a knowledge base.


Vin uses Obsidian and Claude Code to delegate tasks to OpenClaw, an autonomous agent, by managing the vault as the primary source of information.

Streamlines delegation and allows the agent to make decisions with a deeper understanding of the user.

Investigate OpenClaw's capabilities and explore its integration with personal knowledge management systems.


Vin highlights the importance of reflection and note-taking for generating ideas and progressing in life and work.

Emphasizes the value of personal knowledge management for creativity and innovation.

Encourage and facilitate reflection and note-taking as a means of generating ideas and improving personal and professional development.


Vin expresses concern about the privacy implications of giving AI agents access to personal information stored in Obsidian.

Highlights the need for careful consideration of privacy when using AI tools with personal data.

Develop and implement privacy-preserving techniques for using AI with personal knowledge management systems.


The speaker uses daily notes, calendar, and IMessage data to create a prioritized plan for the day.

Provides a more effective way to manage time and tasks by incorporating personal context and priorities.

Develop a system for integrating daily notes, calendar, and messaging data to create a personalized task management system.


The speaker uses confidence markers to rate the strength of their hypotheses.

Allows for prioritization of ideas and projects based on their perceived validity.

Implement a system for assigning confidence ratings to ideas and hypotheses.


Jonathan Courtney uses Claude Code to analyze past podcast episodes to identify what works and what doesn't based on views and comments.

Demonstrates a practical application of AI for content optimization and understanding audience engagement.

Implement similar analysis of past content using Claude Code or similar tools to identify successful patterns and areas for improvement.


Courtney uses Claude Code as a 'marketing assistant' to create graphics and research for podcast appearances.

Illustrates the use of AI to augment marketing tasks, saving time and potentially improving quality.

Explore using Claude Code or similar AI tools to assist with graphic creation and research for marketing activities.


Courtney emphasizes the importance of understanding how to transition between Claude Standard and Claude Code depending on the task.

Highlights the need for users to understand the different capabilities of AI tools and how to leverage them effectively.

Develop training materials or guidelines on when to use Claude Standard vs. Claude Code for different marketing and business tasks.


Courtney describes a three-step sales process: Traffic (organic/paid), Holding Pattern (email newsletter, podcast), and Selling Event (webinar, email campaign, retargeting).

Provides a structured framework for sales and marketing that can be applied to various businesses.

Evaluate current sales and marketing efforts against this framework and identify areas for improvement in traffic generation, holding pattern engagement, and selling event execution.


Courtney emphasizes that a CEO's primary job is promotion and getting customers, not just building cool AI systems.

Highlights a common misconception among builders and emphasizes the importance of marketing and sales.

Re-evaluate time allocation to ensure sufficient focus on promotion and customer acquisition activities.


Courtney mentions using Meta ads to drive traffic into a holding pattern (email newsletter).

Demonstrates a specific tactic for building an audience and nurturing leads.

Explore using Meta ads or other paid advertising platforms to drive traffic to an email newsletter or other holding pattern.


Courtney uses email lists to create lookalike audiences on Facebook for retargeting.

Illustrates a method for expanding reach and targeting potential customers who are similar to existing ones.

Implement lookalike audience targeting on Facebook or other platforms using existing email lists.


Courtney manually reaches out to individuals from enterprise companies who sign up for the email newsletter.

Highlights the value of personalized outreach for high-value leads.

Implement a process for identifying and manually reaching out to potential enterprise clients who engage with marketing materials.


Courtney uses webinars as a 'selling event' to convert leads into customers.

Demonstrates a specific tactic for showcasing product value and driving sales.

Plan and execute webinars to showcase product features, benefits, and use cases.


The speaker mentions facilitator.com and AJ & Smart as examples of businesses they run, with revenue ranging from multi-six to seven figures.

Provides context for the speaker's expertise and credibility in the area of business and revenue generation.

Research facilitator.com and AJ & Smart to understand their business models, target markets, and marketing strategies.


Avoid loading default MCP servers to save ~24,100 tokens (12% of context window).

Elite Context Engineering with Claude Code   IndyDevDan

Significant reduction in wasted context tokens.

Delete the default `mcp.json` and load MCP servers on demand using `claude --mcp-config <specific_config>`.


Use `--strict-mcp-config` to override global MCP configs and ensure only necessary tools are loaded.

Ensures focused agent sessions with minimal context overhead.

Implement `--strict-mcp-config` flag when launching agents.


Context priming is superior to a large `claude.md` file. Trim `claude.md` to absolute universals (~43 lines, ~350 tokens) and use `/prime` commands for task-specific context.

Significant reduction in context window bloat and improved agent focus.

Audit and drastically reduce the size of CLAUDE.md, creating `/prime` commands for common tasks.


Create dedicated `/prime` commands with a structured format: Purpose, Run step, Read step, Report step.

Provides reusable, task-specific context for agents.

Develop `/prime-voice`, `/prime-widget`, `/prime-memory`, `/prime-kg`, `/prime-deploy` commands.


Sub-agent system prompts are separate from the primary agent's context window, consuming only ~122 tokens for the agent definition reference.

Allows delegation of work without bloating the primary agent's context.

Delegate work that would bloat primary context to sub-agents with focused, single-purpose prompts.


Ensure sub-agents have focused, single-purpose prompts to maximize context isolation and efficiency.

Prevents context bleed and improves sub-agent performance.

Audit existing sub-agent prompts to ensure they are focused and avoid unnecessary information.


Implement file-based context bundles using Claude Code hooks to log agent reads/writes to `agents/context-bundles/session_YYYYMMDD_HH_SESSIONID.md`.

Automates session handoff and allows for ~70% state recovery without full replay.

Implement PostToolUse hooks to log agent activity to context bundle files.


Create a `/loadbundle` command to replay a previous agent's context bundle, enabling new agents to quickly understand the previous agent's state.

Improves agent respawn efficiency and reduces boot tax.

Develop a `/loadbundle` command that reads and applies the context from a specified bundle file.


Standardize a report-file-rename convention for background agents to signal completion.

Provides a reliable mechanism for monitoring background agent progress.

Implement a system where background agents rename their report file upon completion.


Ensure every background agent logs its work to a context bundle for traceability and replayability.

Enables debugging, auditing, and improved agent handoff.

Configure background agents to automatically generate context bundles.


Dispatch background agents with focused prompts, ensuring each agent performs a single, well-defined task.

Improves agent efficiency and reduces context window bloat.

Refactor existing multi-step prompts into single-task prompts for background agents.


Audit current CLAUDE.md and MEMORY.md token consumption to quantify the 'boot tax'.

Provides a baseline for measuring the effectiveness of context engineering improvements.

Measure the token usage of CLAUDE.md and MEMORY.md on agent startup.


Create specialized MCP config files for different tasks to load only the necessary MCP tools.

Reduces context window bloat and improves agent focus.

Develop per-task MCP configs (e.g., `voice_mcp.json`, `widget_mcp.json`).


Implement agent spawning with `--mcp-config` to ensure each delegated agent gets only the MCP tools it needs.

Further optimizes context window usage and agent performance.

Modify agent spawning logic to include the `--mcp-config` flag.


Gemini 3 Pro is the new top model, surpassing Claude Code running 4.5 Sonnet in benchmarks.

Indicates a shift in the competitive landscape of LLMs, requiring re-evaluation of model choices for agentic workflows.

Re-evaluate model selection for agentic workflows, prioritizing Gemini 3 Pro for its superior performance.


The presenter uses E2B to host and run agent sandboxes, providing isolated computer environments for agents.

E2B enables greater agent autonomy and reduces management overhead by providing isolated environments.

Evaluate E2B for hosting agent sandboxes to improve agent autonomy and reduce management overhead.


The presenter reprograms agents to use shared skills, like the agent sandbox skill, by modifying memory files and using a special syntax (backslash command).

This allows for dynamic modification of agent behavior and reuse of skills across different agents.

Implement a similar mechanism for reprogramming agents with shared skills using memory files and a special syntax.


The presenter emphasizes the importance of full-stack application development as a benchmark for agentic capabilities, moving beyond simple UI generation.

Highlights the need to evaluate agents based on their ability to perform complex engineering tasks, not just simple ones.

Focus on evaluating agents' ability to build full-stack applications as a key performance indicator.


The presenter believes that the agentic experience and the agent ecosystem are becoming more important than the underlying LLM's intelligence.

Suggests a shift in focus from model performance to the overall agentic system and its ability to solve specific use cases.

Prioritize building a robust agentic ecosystem and focusing on use-case-specific performance over raw model intelligence.


The presenter uses a chained agentic workflow with steps like plan, build, host, and test, broken down into individual prompts.

This allows for complex tasks to be automated by breaking them down into smaller, manageable steps.

Implement a chained agentic workflow with similar steps to automate complex tasks.


The presenter uses memory files to store reusable prompts and agent skills, allowing agents to access and execute them.

This enables agents to learn and reuse skills, improving their efficiency and effectiveness.

Utilize memory files to store reusable prompts and agent skills for improved agent efficiency and knowledge sharing.


The presenter runs multiple instances of agents in parallel to solve the same problem and then chooses the best result (best-of-n approach).

This increases the likelihood of finding a good solution and allows for exploration of different approaches.

Implement a best-of-n approach by running multiple agents in parallel and selecting the best result.


The presenter uses environment variables to provide agents with API keys and other sensitive information within their sandboxes.

This allows agents to access external services securely without exposing sensitive information.

Implement a secure mechanism for providing agents with API keys and other sensitive information using environment variables.


Recursive Language Models (RLMs) treat long prompts as part of an external environment, allowing LLMs to programmatically examine, decompose, and recursively call themselves over snippets of the prompt.

2026 02 09 From Retrieval to Navigation The New RAG Paradigm

RLMs enable LLMs to understand and scale their understanding of content far exceeding their context window (upwards of 10 million+ tokens).

Investigate RLM architecture and its implementation details for potential integration into our AI systems.


RLMs utilize a code execution environment (Python REPL) where the LLM can operate on the prompt as a variable, orchestrating interactions through generated code.

This allows for flexible and creative context management, combining various operations with LLM queries.

Explore the use of code execution environments within our AI agents to enhance context manipulation capabilities.


RLMs employ a language model query function to call separate instances of the LLM for specific tasks, separating tasks into different context windows.

This recursive calling mechanism allows for parallel processing and reduces the load on the primary RLM context.

Design and implement a sub-agent architecture similar to the RLM's language model query function to distribute tasks and manage context more efficiently.


RLMs can be further improved through supervised fine-tuning and reinforcement learning (RL) by training the model on examples of effective tool usage and context navigation.

Training enhances the model's ability to manage context effectively and improves its performance on long-context tasks.

Develop a supervised fine-tuning and RL training pipeline for our AI agents to improve their context management skills.


The video discusses the shift from retrieval-based context engineering (RAG) to navigation-based context engineering, where the LLM is given tools to navigate and manage context itself.

Navigation-based context engineering allows the model to progressively discover information, bypassing the limitations of traditional search systems.

Evaluate the feasibility of transitioning from RAG to a navigation-based context engineering approach for our AI systems.


The video mentions coding agents like Cursor Agent, Codeex, and Claude Code as examples of systems that allow language models to operate and search over large codebases.

These agents demonstrate the effectiveness of providing LLMs with tools to navigate and interact with complex environments.

Research and analyze the architectures of Cursor Agent, Codeex, and Claude Code to identify best practices for building coding agents.


The video highlights the problem of 'context rot,' where the performance of LLMs declines as the context window grows, especially with the introduction of distractors.

Context rot limits the effectiveness of large context windows and necessitates more sophisticated context engineering techniques.

Implement techniques to mitigate context rot, such as context summarization, filtering, and re-ranking, in our AI systems.


The video mentions Chroma's technical report on context rot and needle in a haystack testing.

Chroma's research provides valuable insights into the limitations of large context windows and the challenges of retrieving relevant information.

Review Chroma's technical report on context rot and needle in a haystack testing to gain a deeper understanding of the issue.


The video discusses positional biases in LLMs, where the model better interprets context at the beginning or end of the input sequence ('lost in the middle').

Positional biases can lead to inaccurate interpretations of context and necessitate strategies to mitigate this effect.

Implement techniques to address positional biases, such as reordering context or using attention mechanisms that are less sensitive to position.


Recursive Language Models (RLMs) treat long prompts as part of an external environment, allowing the LLM to programmatically examine, decompose, and recursively call itself over snippets of the prompt.

2026 02 26 from retrieval to navigation the new rag paradigm

Investigate RLM architecture and its applicability to Genesis AI for handling large knowledge bases and complex tasks.


RLMs use a code execution environment (Python REPL) where the prompt is passed as a variable, enabling the LLM to orchestrate interactions through code.

This allows for dynamic manipulation and exploration of the prompt, leading to unique ways of solving and managing context.

Explore integrating a code execution environment within Genesis AI to enable dynamic context manipulation.


RLMs leverage the LLM's ability to call other LLM instances (sub-agents) in fresh context windows for specific tasks.

This separates individual tasks into separate context windows, improving efficiency and reducing context window limitations.

Design a sub-agent architecture within Genesis AI that allows for task delegation to separate LLM instances.


RLMs can be improved through supervised fine-tuning and reinforcement learning.

Training on examples of effective tool usage and context navigation can further increase performance and instill context management understanding directly into the model weights.

Develop a supervised fine-tuning and RL training pipeline for Genesis AI, focusing on context management and tool usage within the RLM framework.


Context rot is a phenomenon where LLMs experience a decline in performance and accuracy as the context window grows, particularly beyond 100,000 tokens.

This limits the effectiveness of large context windows and necessitates improved context engineering techniques.

Implement needle-in-a-haystack testing to evaluate and mitigate context rot in Genesis AI.


LLMs exhibit positional biases, better interpreting context at the beginning or end of the input sequence (lost in the middle).

This affects the ability to accurately retrieve and utilize information from the middle of the context window.

Investigate and implement techniques to mitigate positional biases in Genesis AI, such as reordering context or using attention mechanisms that are less sensitive to position.


File system search, where LLMs are given tools to navigate and explore a knowledge base like a computer file system, is an alternative to vector-based similarity search.

This shifts context management responsibility to the model and enables progressive discovery of information.

Explore integrating a file system search capability into Genesis AI, providing the model with tools like `grep`, `ls`, `cat`, and `cd` to navigate and inspect large knowledge bases.


Cursor Agent, Codeex, and Claude Code are examples of coding agents that allow LLMs to operate over and search large code bases.

These agents demonstrate the effectiveness of providing LLMs with tools to navigate and understand complex code environments.

Analyze the architectures and functionalities of Cursor Agent, Codeex, and Claude Code to identify best practices for building coding agents within Genesis AI.


Grade 1 agentic layer consists of a prime prompt and memory files.

The Codebase Singularity   My agents run my codebase better than I can   IndyDevDan

Provides a minimal starting point for agentic layer implementation.

Implement a .claude.md memory file and a .do/commands/prime.md activatable prompt in new projects.


Grade 2 agentic layer adds specialized prompts (plan.md) and sub-agents (fetch-docs, test-writer).

Enables specialization and parallelization of agent workflows.

Implement plan prompts and sub-agents for documentation fetching and test writing.


Grade 3 agentic layer introduces custom tools via Skills, MCP servers, and tool-enhanced prompts.

Enhances agent capabilities with access to specific functionalities.

Develop custom skills for database migration and application start/stop using scripts instead of MCP servers where possible.


Skills and MCP servers can be replaced with well-crafted prompts using the Core Four (Context, Model, Prompt, Tools).

Reduces complexity and token usage by optimizing prompts.

Prioritize prompt engineering to replace MCP server calls and skills where feasible.


Engineers often have too many tools, leading to token waste and scalability issues.

Overengineered tools can negatively impact performance and cost.

Conduct a tool audit to identify and eliminate unnecessary or inefficient tools.


Grade 4 agentic layer incorporates closed-loop feedback prompts (Request -> Validate -> Resolve) for self-correcting agents.

Enables agents to self-correct and improve their performance.

Implement Request -> Validate -> Resolve cycles in build prompts to create self-correcting agents.


Adding more compute (feedback loops) increases confidence in agent results.

Improves the reliability and accuracy of agent outputs.

Prioritize feedback loops even if they increase token usage.


Grade 5 agentic layer focuses on thread engineering for scaling work further.

Enables further scaling of agentic layer capabilities.

Investigate and implement thread engineering techniques to scale agent workflows.


Class 3 systems use an orchestrator agent to control AI developer workflows (plan-build-review-fix).

Automates end-to-end AI development processes.

Develop a single command that runs the full plan-build-review-fix cycle.


The Agentic Layer should be bundled AROUND applications, not inside them, to give agents cross-repo visibility.

Enables agents to operate across multiple applications and repositories.

Ensure the agentic layer is designed to wrap around multiple applications/repos.


Progressive Specialization: Start generic (plan, build), then specialize (test-backend, test-frontend, review-code). Prompts should get more specific as the codebase grows.

Improves efficiency and accuracy of agent tasks.

Implement specialized prompts for each sub-project (Sunaiva, ReceptionistAI) for testing, building, and reviewing.


Codebase Singularity is the point where agents run the codebase better than engineers.

Represents a significant milestone in agentic layer development.

Define metrics to track progress towards the Codebase Singularity.


Genesis is assessed to be at Class 3, Grade 4+.

Provides a benchmark for current capabilities and identifies areas for improvement.

Build a self-assessment tool to automatically evaluate the agentic layer power.


Genesis lacks a dedicated directory for agent review outputs (app-reviews/).

Makes it difficult to track and analyze agent review results.

Create an app-reviews/ directory to store agent review outputs.


Package Genesis AI voice agent offering as a Claude Plugin for Claude Co-work users.

Claude Plugins Give You Superpowers   Heres How to Unlock Them (Rick Mulready)

Direct revenue opportunity, leveraging existing Genesis skills and agents.

Develop a Claude Plugin that replicates Sunaiva/ReceptionistAI functionality, focusing on ease of installation and customization.


Productize AI receptionist setup as a Claude Plugin, configuring Claude with customer's business context and MCP tool connections.

Shift from service-based revenue to productized revenue with zero marginal cost after plugin creation.

Create a Claude Plugin template for AI receptionist setup, allowing for easy customization and integration with Genesis MCP.


Offer a custom Claude Plugin creation service for businesses.

Immediate revenue stream by leveraging the ease of plugin creation demonstrated in the video.

Develop a service offering for custom Claude Plugin creation, priced between $500-2,000, focusing on rapid turnaround and tailored solutions.


Genesis Skills Registry can be exported as Claude Plugins and distributed via GitHub marketplace.

Expand reach and visibility of Genesis skills by leveraging the Claude Plugin ecosystem.

Develop a tool to export Genesis skills in `.claude/skills/` registry as compatible Claude Plugins for distribution.


Leverage Genesis MCP Bloodstream architecture as a 'super-connector' plugin for Claude.

Provide a unified connection point for various MCP tools, enhancing the value of Claude Plugins.

Create a Claude Plugin that utilizes Genesis MCP to connect to a wider range of tools than individual plugins typically support.


Position Sunaiva's AI Memory product as 'Plugin memory on steroids' to differentiate from Claude's local memory feature.

Highlight the superior depth and capabilities of Sunaiva's memory solution compared to the basic memory features in Claude Plugins.

Develop marketing materials that showcase the advanced features of Sunaiva AI Memory compared to Claude Plugin memory, focusing on depth and scalability.


The legal plugin's market impact validates the 'virtual employee' positioning.

Reinforces the market's fear and interest in AI-powered virtual employees, strengthening Genesis/Sunaiva's core value proposition.

Adjust marketing messaging to emphasize the 'virtual employee' aspect of Genesis/Sunaiva offerings, highlighting the potential for automation and cost savings.


Implement a content flywheel pattern similar to Rick's custom plugin (intake from Google Sheet -> analyze past content -> apply style guide -> generate new ideas with persistent memory) for Genesis's marketing engine.

Improve the efficiency and effectiveness of Genesis's marketing content creation process.

Develop a workflow within Genesis that replicates the content flywheel pattern, integrating data intake, content analysis, style guide application, and content generation with persistent memory.


Leverage Claude Teams' plugin sharing feature for Sunaiva's B2B sales strategy.

Increase the impact of Sunaiva's B2B sales by enabling plugin propagation across entire companies.

Incorporate Claude Teams plugin sharing into Sunaiva's B2B sales pitch, highlighting the potential for company-wide adoption and consistent knowledge sharing.


Analyze Recall (getrecall.ai) as a competitor to Sunaiva AI Memory.

Understand the competitive landscape and identify potential differentiation points for Sunaiva AI Memory.

Conduct a detailed competitive analysis of Recall, focusing on features, pricing, and target audience, to identify opportunities for Sunaiva AI Memory to differentiate and improve its offering.


The customization flow of Claude plugins (Install -> Customize -> Claude asks questions -> Learns your specific workflow) can be replicated in Genesis.

Improve the user experience and ease of onboarding for Genesis products.

Implement a similar customization flow in Genesis products, guiding users through a series of questions to personalize the system to their specific needs and workflows.


Explore integrating with tools mentioned in the video (Slack, Canva, Figma, HubSpot, Amplitude, Notion, Ahrefs, SimilarWeb, Klaviyo) via MCP.

Expand the functionality and value of Genesis products by connecting to popular business tools.

Prioritize integration with the mentioned tools via Genesis MCP, based on user demand and potential impact on product functionality.


The productivity plugin creates local memory (context/, people/, projects/).

Illustrates the importance of persistent memory for AI agents.

Continue development and refinement of Sunaiva's AI Memory product, focusing on features that enhance persistent memory and context retention.


The custom plugin creation process involves Claude asking a series of questions to generate commands and files.

Highlights the potential for AI-assisted plugin/skill creation.

Explore developing a feature within Genesis that allows users to create custom skills or plugins by answering a series of questions, leveraging AI to generate the necessary code and configurations.


Claude can generate Excalidraw JSON and draw.io XML files to create visual business process diagrams (mind maps, swim lanes, process flows).

How I Use AI to Map and Design Business Systems (Claude Code)   Rashid

Enables automated generation of business process diagrams, useful for onboarding, documentation, and identifying automation opportunities.

Investigate using Claude (via API or Claude Code) to generate business process diagrams for Sunaiva onboarding and internal architecture documentation.


draw.io XML is more token-efficient than Excalidraw JSON for generating diagrams.

Reduces token consumption and cost when generating diagrams with Claude.

Prioritize draw.io XML format over Excalidraw JSON when generating diagrams with Claude.


The 'Business X-Ray' agent skill interviews the business owner to extract processes and generate a visual business map automatically.

Automates business process mapping, reducing manual effort and improving onboarding.

Explore replicating the 'Business X-Ray' concept as a Genesis skill for Sunaiva onboarding, interviewing customers and auto-generating AI agent configurations.


Claude Code allows interactive editing of diagrams directly in VS Code, while the Claude web app requires downloading and uploading files for each edit.

Streamlines diagram editing and iteration, improving efficiency.

Utilize Claude Code with VS Code extensions for interactive diagram editing and version control of Genesis architecture diagrams.


Rashid uses a 'skill file' to teach Claude how to generate Excalidraw visuals with specific formatting (arrow binding, layout).

Improves the quality and consistency of AI-generated diagrams.

Download and adapt Rashid's free Excalidraw skill for Genesis use, and create similar skills for draw.io diagram generation to ensure consistent formatting and layout.


AI-generated business maps can be a premium deliverable for customers, showcasing the AI's role in their workflow.

Increases perceived value and differentiates the product from competitors.

Offer AI-generated business maps ('Your AI Business Blueprint') as a premium deliverable in the Talking Widget / ReceptionistAI package.


Rashid's 'Chief Leverage Officer' framework maps business processes, identifies manual work, and applies filters (Eliminate, Delegate, Simplify, Automate) to implement AI agents and digital assets.

Provides a structured approach to business optimization and AI integration.

Incorporate the 'Chief Leverage Officer' framework into Sunaiva onboarding and customer success processes to guide customers in identifying and implementing AI solutions.


The video highlights the potential for one-person billion-dollar companies leveraging AI agents and digital assets.

Reinforces the importance of AI leverage for scaling businesses with minimal human involvement.

Continue to focus on building AI-powered solutions that enable businesses to scale efficiently with minimal human intervention.


Rashid uses draw.io multi-page diagrams to represent different levels of detail in business processes.

Allows for comprehensive documentation of complex systems in a single file.

Use multi-page draw.io files to document Genesis architecture, with one page per subsystem (Memory, Voice, Execution, Agents). Store in `docs/diagrams/` as `.drawio` files.


The video demonstrates using Claude Code to modify existing diagrams, such as changing colors.

Enables automated updates and customization of diagrams.

Explore using Claude Code to automate updates and customization of Genesis architecture diagrams based on code changes or other triggers.


Rashid uses swim lane diagrams to compare traditional (unleveraged) and leveraged business models, highlighting the owner's involvement in each.

Provides a clear visual representation of the benefits of AI leverage.

Use swim lane diagrams to illustrate the impact of Sunaiva on customer workflows, showcasing how AI reduces manual tasks and increases efficiency.


Add MCP prompts (slash commands) to the genesis-core MCP server to expose common Genesis workflows.

5 Agent PATTERNS to SIMPLIFY Your Agentic Coding (Claude Code, Gemini CLI, MCP)   IndyDevDan

Increased agent accessibility to core workflows, improved reusability, and reduced manual intervention.

Implement MCP prompts for frequently used Genesis workflows within the genesis-core MCP server.


Enforce the 'Rule of Three': Any task performed 3+ times should be codified into a reusable prompt/skill.

Increased automation, reduced repetitive tasks, and improved overall efficiency.

Audit existing workflows and identify tasks performed 3+ times for conversion into reusable prompts/skills.


Conduct an audit of Agent Teams patterns to ensure clear prompt clarity going IN to sub-agents and high-quality results coming OUT.

Improved reliability and effectiveness of multi-agent workflows by addressing potential information flow bottlenecks.

Review and refine prompts used in Agent Teams patterns, focusing on clarity and expected output format.


Build a wrapper MCP server integrating Telnyx, Replicate, and internal services behind a unified interface.

Centralized access to diverse services, simplified agent integration, and enhanced workflow orchestration.

Design and implement a wrapper MCP server incorporating Telnyx, Replicate, and relevant internal APIs.


Apply the agent pattern ladder (Ad-hoc -> Reusable -> Sub-Agents -> Prompt-to-Sub-Agent -> Wrapper MCP -> Application) when designing new features, defaulting to the simplest pattern that works.

Reduced complexity, faster development cycles, and avoidance of premature optimization.

Incorporate the agent pattern ladder into the feature development process, emphasizing simplicity and incremental scaling.


Develop a library of reusable TOML prompts for common Gemini CLI tasks, complementing existing Claude Code skills.

Increased efficiency and reusability of Gemini CLI interactions, providing a viable alternative to Claude Code for certain tasks.

Identify frequently used Gemini CLI commands and create corresponding TOML prompts.


Prioritize MCP-based patterns (Bloodstream, wrapper servers) over Claude-specific sub-agents to maintain cross-agent portability and mitigate Claude Code lock-in.

Reduced vendor lock-in, increased flexibility, and ensured compatibility with future agent platforms.

Favor MCP-based solutions when designing new agent workflows, minimizing reliance on Claude Code-specific features.


Clawed Code Damage Control skill provides a configurable system of hooks (local, global, prompt) to prevent agents from running destructive commands.

Reduces risk of accidental or malicious damage to production assets by AI agents.

Evaluate and potentially integrate the Clawed Code Damage Control skill into existing agentic workflows.


The /install command is a new pattern for interactive installation processes, guiding users through setup with agent assistance.

Simplifies and standardizes the installation of complex tools and skills.

Adopt the /install pattern for creating interactive installation experiences for new tools and skills.


Prompt hooks are a last-ditch effort to catch dangerous commands that haven't been explicitly caught by deterministic hooks.

Provides an additional layer of security against unforeseen destructive actions.

Implement prompt hooks in addition to deterministic hooks to catch potentially harmful commands.


Patterns.yaml file allows for quick addition and modification of blocked commands or commands requiring user confirmation.

Simplifies the management of security rules and allows for dynamic updates.

Utilize a patterns file (e.g., YAML) to manage blocked commands and commands requiring user confirmation.


Global hooks can be set up to apply to all agent operations on a device, providing a consistent security layer.

Ensures consistent security across all projects and environments.

Implement global hooks in addition to project-level hooks to enforce security policies consistently.


The skill utilizes a cookbook (agentic workflow) to guide users through the installation process.

Provides a structured and automated approach to setting up the damage control system.

Use agentic workflows (cookbooks) to automate and standardize the setup and configuration of complex tools and skills.


The system includes zero access paths, read-only paths, and no delete paths for granular control over file access.

Provides fine-grained control over agent access to sensitive files and directories.

Implement granular access control policies using zero access, read-only, and no delete paths.


Sandboxes can be used to completely defer trust and allow agents to run in isolated environments.

Reduces the need for trust in agents by isolating them from critical systems.

Explore and implement sandboxing techniques to isolate agents and minimize the risk of damage.


The creator experienced a near-catastrophic event, prompting the development of the damage control skill.

Highlights the real-world risks associated with agentic coding and the importance of proactive security measures.

Prioritize security and implement proactive measures to prevent accidental or malicious damage by AI agents.


The creator plans to fork the public version of the skill and build a more specific version for personal use.

Demonstrates the value of open-source projects and the ability to customize them to specific needs.

Consider forking and customizing open-source tools and skills to meet specific requirements.


The video mentions Claude Code and Opus having built-in protections, but emphasizes the need for additional layers of security.

Highlights the importance of defense-in-depth and not relying solely on built-in security features.

Implement multiple layers of security, including hooks and sandboxes, in addition to built-in protections.


The video promotes the use of skills as reusable collections of resources for agentic coding.

Encourages the development and sharing of reusable skills to improve efficiency and consistency.

Develop and share reusable skills to streamline agentic coding workflows and promote best practices.


The video mentions the hierarchy of cloud code hooks: user level, project level, local level, and enterprise level.

Understanding the hierarchy is important for configuring the hooks correctly.

Document and understand the hierarchy of cloud code hooks to ensure proper configuration.


Looped Language Models (LLMs) offer a third axis of scaling (beyond model size and dataset size) by merging reasoning with pre-training.

2026 02 26 llms dont need more parameters they need loops

Potential for significant performance gains, especially in knowledge manipulation tasks, without drastically increasing model size or data requirements.

Explore incorporating looped architectures into Genesis AI models to improve reasoning capabilities and parameter efficiency.


Oro models (1.4B and 2.6B parameters) with looped architectures perform on par with or better than larger models like QN3 (3x larger) and Gemma 3 (5x larger) on certain benchmarks.

Demonstrates the potential for looped architectures to achieve state-of-the-art performance with smaller, more efficient models.

Benchmark Oro models against existing Genesis AI models to quantify performance improvements and identify optimal configurations for specific tasks.


The exit gate mechanism in Looped LLMs uses a dense layer with a sigmoid activation to determine whether to exit a loop or continue iterating.

Provides a mechanism for dynamic reasoning and efficient computation by allowing the model to adaptively determine the number of loops required for a given task.

Investigate the implementation details of the exit gate mechanism and explore alternative architectures or activation functions to optimize performance and efficiency.


Entropy regularization with a uniform prior is crucial for preventing reward hacking and ensuring that the model effectively utilizes all loops during training.

Highlights the importance of careful training techniques to avoid instability and ensure that the model learns to reason effectively.

Implement entropy regularization with a uniform prior when training looped architectures to prevent reward hacking and ensure optimal performance.


Looped LLMs excel at knowledge manipulation tasks (reasoning and operating on stored facts) but do not significantly improve knowledge storage and extraction (memorization).

Provides insights into the strengths and weaknesses of looped architectures and suggests that they are particularly well-suited for tasks that require reasoning and problem-solving.

Focus on applying looped architectures to tasks that require knowledge manipulation, such as code generation, question answering, and decision-making.


The optimal number of loops for a given task varies, and overlooping can sometimes degrade performance.

Suggests that dynamic loop control mechanisms or adaptive architectures may be necessary to optimize performance across different tasks and datasets.

Explore dynamic loop control mechanisms or adaptive architectures that can automatically adjust the number of loops based on the complexity of the task.


The paper mentions training a 1.4B parameter model on 3 trillion tokens and then forking it into a 2.6B parameter model, resembling a 2x loop pass.

Provides a concrete example of how to train and scale looped architectures, which can be used as a starting point for developing Genesis AI models.

Investigate the training pipeline used for the Oro models and adapt it for training Genesis AI models with looped architectures.


The speaker mentions that the training pipeline for looped models is a "monstrous engineering effort" and highlights the challenges of maintaining training stability.

Highlights the need for robust infrastructure and monitoring tools to ensure the successful training of looped architectures.

Invest in robust infrastructure and monitoring tools to support the training of looped architectures and address potential stability issues.


The speaker mentions that injecting multi-step thinking or looping into the pre-training pipeline can lift performance and improve parameter efficiency, especially for small language models.

Suggests that looped architectures can be particularly beneficial for resource-constrained environments, such as mobile devices.

Explore the use of looped architectures for developing small, efficient Genesis AI models that can be deployed on mobile devices or other resource-constrained platforms.


The speaker draws an analogy between looped language models and the brain, suggesting that they can learn to use pre-existing neurons and synapses more effectively.

Provides a conceptual framework for understanding the benefits of looped architectures and suggests that they may be more biologically plausible than traditional feedforward networks.

Explore the potential for incorporating biologically inspired mechanisms into looped architectures to further improve performance and efficiency.


Looped Language Models (LLMs) offer a third axis of scaling by merging reasoning with pre-training, decoupling data from compute.

2026 02 10 LLMs Dont Need More Parameters They Need Loops

Potential for more efficient use of compute and data in LLM training, leading to better performance with smaller models.

Investigate Looped LLM architectures and training methodologies for potential performance gains and resource optimization.


Oro models (1.4B and 2.6B parameters) with looping perform on par with significantly larger models (QN3, Gemma 3).

Demonstrates the potential of Looped LLMs to achieve competitive performance with reduced model size.

Benchmark Oro models against existing LLMs in specific use cases to validate performance claims and identify optimal applications.


The exit gate mechanism in Looped LLMs uses a dense layer with sigmoid activation to determine when to terminate a loop, requiring a specific probability calculation to avoid reward hacking.

Highlights the importance of proper training techniques to ensure effective looping and prevent model collapse.

Implement entropy regularization with a uniform prior in the loss function to encourage a balanced distribution of exit probabilities across loops.


Looped LLMs improve knowledge manipulation capabilities (reasoning and operating on stored facts) but do not significantly enhance knowledge storage and extraction (memorization).

Suggests that Looped LLMs are particularly well-suited for tasks requiring reasoning and problem-solving, rather than simple information retrieval.

Focus Looped LLM development on applications that benefit from enhanced reasoning abilities, such as complex question answering, code generation, and decision-making.


KV cache management in Looped LLMs presents unique challenges and opportunities, with different strategies for training, prefill, and decoding.

Optimizing KV cache usage can significantly impact the performance and efficiency of Looped LLMs.

Experiment with different KV cache strategies during inference, such as using the KV cache from the exit loop or averaging the KV cache from every loop, to identify the most effective approach.


The Oro paper uses a two-phase pre-training approach, first optimizing a smaller model and then forking it into a larger model with relaxed weights.

This approach can save on compute costs during pre-training.

Consider a similar two-phase pre-training approach when training Looped LLMs to reduce computational expenses.


The speaker mentions the importance of small language models that can fit on mobile devices and how looping can help lift parameter efficiency.

Highlights the potential of Looped LLMs for resource-constrained environments.

Explore the use of Looped LLMs for edge computing and mobile applications, focusing on optimizing performance and memory footprint.


The paper being discussed is titled "Scaling Latent Reasoning via Looped Language Models".

Provides a specific resource for further research.

Locate and thoroughly review the paper "Scaling Latent Reasoning via Looped Language Models" for detailed information on the architecture, training, and evaluation of Oro models.


The speaker references work by Turuan Alanju and Shaoli Shu on the physics of language models.

Provides a theoretical framework for understanding knowledge storage and manipulation in LLMs.

Investigate the work of Turuan Alanju and Shaoli Shu on the physics of language models to gain a deeper understanding of the underlying principles of knowledge representation and reasoning in LLMs.


The speaker mentions PonderNet from Google DeepMind as inspiration for using a geometric distribution to encourage early exiting, but found a uniform prior to be more effective.

Provides insight into alternative approaches and the rationale for choosing a uniform prior in the Oro model.

Compare the performance of Looped LLMs trained with geometric and uniform priors to validate the speaker's findings and identify the optimal approach for specific tasks.


Paige uses data science to determine the optimal frequency for actions like image uploads, automatically adjusting based on algorithm changes.

Reduces manual intervention and optimizes performance based on real-time data.

Investigate Paige's data science methods for potential application in our own systems. Explore dynamic frequency adjustments for content posting and other automated tasks.


Paige uses 'training notes' to allow users to customize the AI's content generation, such as adding a specific hashtag to every post.

Enables fine-grained control over AI-generated content and ensures brand consistency.

Implement a similar 'training' or 'prompt engineering' feature in our AI systems to allow users to customize the output based on specific requirements.


Paige reads the client's website to understand the business and generate hyper-specific content.

Improves the relevance and quality of AI-generated content, making it sound like it was written by someone familiar with the business.

Integrate website scraping and analysis into our content generation process to improve the relevance and specificity of the output.


Paige offers a white-labeled GBP management service that agencies can resell at a markup (e.g., $99/month to $400-$800/month).

Provides a clear revenue model for agencies and allows them to offer a high-value service without significant overhead.

Explore white-labeling opportunities for our AI solutions to enable agencies to resell them under their own brand.


Paige includes an automated 'Account Manager' feature that sends regular 'What's New' emails, review reminders, and positive reinforcement messages to clients.

Improves client engagement, reduces churn, and automates communication tasks.

Develop an automated client communication system that proactively engages with clients, provides updates, and requests feedback.


Paige provides a churn prediction feature that identifies clients at risk of canceling based on inactivity signals.

Allows agencies to proactively address potential churn and improve client retention.

Implement a churn prediction model that identifies at-risk clients based on usage patterns and engagement metrics.


Paige creates videos and publishes them to Google Business Profile, YouTube, Instagram, Facebook, and LinkedIn.

Increases visibility across multiple platforms and improves SEO.

Develop a video creation and distribution tool that automatically generates and publishes videos to various social media platforms.


Paige offers a SAM (Sales Automation Machine) tool in beta that provides leads to call every day with details helpful to sell local marketing services.

Streamlines lead generation and provides valuable insights for sales teams.

Explore the development of a lead generation tool that provides targeted leads and relevant information for sales teams.


Paige integrates with Google Drive and Box via webhooks for image uploads.

Simplifies image management for clients and streamlines the content creation process.

Implement webhook integrations with popular cloud storage services to facilitate seamless content uploads.


Paige's pricing is $99/month per Google Business Profile, which agencies mark up to $400-$800/month.

Provides a benchmark for pricing similar services and highlights the potential for high profit margins.

Analyze Paige's pricing model and compare it to our own to identify opportunities for optimization and competitive pricing.


Paige optimizes images by renaming them with target keywords, geo-tagging them, and writing meta descriptions.

Improves image SEO and increases visibility in local search results.

Implement image optimization techniques, including keyword renaming, geo-tagging, and meta description writing, into our content creation process.


Paige has a feature that audits old bad reviews and flags them with Google if they violate terms and conditions.

Helps businesses remove illegitimate negative reviews and improve their online reputation.

Develop a review auditing tool that identifies potentially fraudulent or policy-violating reviews and provides guidance on how to flag them with Google.


Paige creates an FAQ widget for client websites to educate LLMs about the business.

Improves the accuracy and relevance of AI-powered search results and chatbots.

Develop an FAQ widget that can be easily embedded on client websites to provide structured information for LLMs.


Paige creates rich schema markup for client websites based on data from the website and Google Business Profile.

Improves website SEO and helps search engines understand the business.

Develop a schema markup generator that automatically creates detailed schema based on website and Google Business Profile data.


Paige offers a citations service that distributes optimized business information to major directories.

Improves local SEO and increases online visibility.

Integrate with citation management services or develop our own tool to distribute business information to relevant directories.


Paige can turn positive reviews into social media posts, leveraging the review's context and associated images.

Automates social media content creation and amplifies positive customer feedback.

Develop a feature that automatically generates social media posts from positive reviews, incorporating relevant images and context.


Paige checks rankings on major AI platforms (ChatGPT, Gemini, Grok, Llama, Perplexity) in addition to traditional search engines.

Provides insights into how businesses are performing in the emerging AI-powered search landscape.

Incorporate AI platform ranking checks into our reporting and analytics dashboards.


Clay Lawrence upselling existing review clients to Paige's automated SEO service.

Demonstrates a successful strategy for increasing revenue from existing clients.

Develop a similar upsell strategy for our existing clients, focusing on high-value services that complement their current offerings.


Skills are folders of instructions, scripts, and resources that agents use to perform tasks more accurately and efficiently. The core is the skill.md file (SOP), with additional instructions on using knowledge files, tools, sub-agents, and code executions.

2026 02 26 how to build claude skills better than 99 of people

Defines the fundamental building block for AI agent automation.

Adopt a skill-based architecture for AI agent development, focusing on modularity and reusability.


Progressive disclosure is used to manage context. Only skill metadata (name and description) is stored in the agent's memory. The skill.md and reference files are loaded into the context window only when the skill is triggered.

Enables agents to access thousands of skills without context overload.

Implement progressive disclosure for managing context in AI agent systems to improve efficiency and scalability.


Plugins are packaged sets of skills, commands, agents, and connectors, adding a layer of complexity on top of skills. They can be shared between departments and are versionable.

Provides a mechanism for bundling and distributing AI agent capabilities.

Explore plugin architectures for organizing and deploying AI agent functionalities, considering versioning and departmental sharing.


Skills and plugins are relevant for any industry, business, department, and niche workflow. Three layers are emerging: general plugins/skills, marketplaces of skills, and company-specific customizations.

Highlights the broad applicability and customization potential of skills and plugins.

Develop a strategy for creating, customizing, and deploying skills and plugins tailored to specific business needs and workflows.


Skills can be built by either manually performing a task with an AI agent and saving it as a skill, or by instructing the agent on how to build the skill directly.

Offers flexibility in skill creation, catering to different levels of expertise and automation requirements.

Implement both methods for skill creation to accommodate various use cases and user skill levels.


Building good skills is like software engineering for AI agents, requiring consideration of UX, context engineering, feature addition/removal, and edge case handling. Skills are never finished and improve with use.

Emphasizes the iterative and evolving nature of skill development.

Adopt a software engineering mindset for skill development, focusing on continuous improvement and user feedback.


A key step is to define the ideal step-by-step process and identify relevant knowledge sources before prompting to build or customize a skill.

Highlights the importance of planning and preparation in skill development.

Establish a structured process for skill development, including process mapping and knowledge source identification.


The framework for building skills includes defining the name and trigger, goal/objective, context on connectors/APIs/MCPs, a step-by-step process with human-in-the-loop considerations, and rules to prevent errors.

Provides a structured approach to skill development.

Utilize the provided framework for building skills to ensure completeness and consistency.


Instruct the skill to be automatically updated and improved when used, making it self-learning. Save approved final outcomes as good examples for training.

Enables continuous improvement and adaptation of skills.

Implement mechanisms for self-learning and continuous improvement in skills, such as saving approved outputs as training data.


If the agent doesn't follow the process correctly, make changes to the skill.md. If additional information is needed, add a reference file. If it does something wrong consistently, add a rule or update the knowledge file. If it struggles with software, create an MCP reference doc.

Provides guidelines for troubleshooting and improving skill performance.

Establish clear guidelines for debugging and improving skill performance based on the observed behavior of the agent.


Skills can be shared as zip files or deployed through GitHub. Plugins can be bundled and shared similarly. Businesses can create plugin marketplaces.

Facilitates collaboration and distribution of skills and plugins.

Implement mechanisms for sharing and deploying skills and plugins, such as zip file sharing and GitHub integration.


Good skills will likely become monetizable soon, sort of like a new software layer. Individuals can monetize skills by providing them to the general public.

Highlights the potential for revenue generation through skill development.

Explore potential revenue models for skills, such as marketplace sales or SaaS offerings.


SAS will start to launch their own plugins with their specific functionalities.

Indicates a shift towards SAS companies integrating AI agent capabilities into their offerings.

Monitor SAS companies for the release of AI agent plugins and assess their potential impact on existing workflows.


There are marketplaces of skills like Skills MP Smithy where people are building and potentially selling them.

Highlights the emergence of a market for pre-built skills.

Research existing skill marketplaces (e.g., Skills MP Smithy) to identify potential skills to leverage or compete with.


MCP instructions file lays out to the agent how to use a specific tool efficiently in this specific skill process. The agent can build these MCP documents.

Enables efficient tool usage within skills.

Implement MCP (Machine Control Program) instructions for tools used within skills, and automate the generation of these MCPs by the agent itself.


2026 02 24 How to build Claude Skills Better than 99 of People

Provides a clear definition of what constitutes a 'skill' in the context of AI agents, highlighting the importance of structured instructions and resources.

Adopt a folder-based structure for AI agent skills, including a skill.md file for SOPs and separate files for knowledge, tools, sub-agents, and code.


Progressive disclosure is used to manage context. Only skill metadata (name and description) is stored in the agent's memory. The skill.md and reference files are loaded into the context window only when the skill is triggered and requires them.

Allows agents to access thousands of skills without being overloaded with context, improving efficiency and scalability.

Implement progressive disclosure for skill management, loading only necessary context into the agent's context window when a skill is triggered.


Skills can be self-improving by instructing the agent to automatically update and improve the skill based on usage, such as updating rules when a clear thing not to do is defined or saving approved final outcomes as good examples.

Enables continuous improvement of skills over time, leading to better performance and reduced maintenance effort.

Incorporate self-improving instructions into skill definitions, such as updating rules based on negative feedback and saving approved outputs as positive examples.


Plugins are packaged sets of skills, commands, agents, and connectors, adding a layer of complexity on top of skills. They can be shared between departments and versioned, making them resemble SaaS offerings.

Plugins offer a way to bundle and distribute skills, enabling more complex workflows and easier sharing within organizations.

Explore the use of plugins to bundle and distribute skills, commands, agents, and connectors for specific departments or use cases.


There are three layers of skills and plugins: general plugins/skills (Entropic, OpenAI), marketplaces of skills (Skills MP Smithy), and custom skills built by companies based on their unique processes.

Highlights the different sources of skills and the importance of building custom skills to address specific business needs.

Evaluate existing skill marketplaces and identify opportunities to build custom skills tailored to specific business processes and expertise.


Skills can be monetized by providing them to the general public, similar to a new software layer. This can be done through skill marketplaces or by offering custom skill development services.

Identifies a potential revenue stream through the creation and distribution of valuable AI agent skills.

Explore opportunities to monetize skills through marketplaces, custom development services, or SaaS offerings.


The AI Accelerator offers templates and blueprints for building AI skills, along with weekly AI workshops and blueprints for starting a business and finding clients.

Provides a resource for learning and accessing pre-built skills and templates.

Evaluate the AI Accelerator for potential use of its templates, blueprints, and workshops to accelerate skill development.


MCP (presumably Master Control Program) instructions files are used to guide the agent on how to efficiently use a specific tool within a skill process. Agents can build these MCP documents.

Ensures proper and efficient usage of external tools and software within the skill execution.

Implement MCP instruction files within skills to guide agents on using specific tools, and leverage the agent's ability to generate these files.


Skills and plugins are becoming versionable, allowing updates to be pushed across all accounts using them, similar to SaaS updates.

Enables centralized management and improvement of skills and plugins, ensuring consistency and reducing maintenance overhead.

Implement a versioning system for skills and plugins to facilitate updates and ensure consistency across all users.


The presenter uses a framework for building skills that includes defining the skill name and trigger, defining the goal, providing context on connectors/APIs/MCPs, laying out the process step-by-step (including human-in-the-loop considerations), and defining rules.

Provides a structured approach to skill development, ensuring that all key aspects are considered.

Adopt the presenter's framework for building skills, including defining the name/trigger, goal, context, process, and rules.


Conversation history is persisted via YAML files using the `--id` parameter, enabling session continuity.

Allows for maintaining context across multiple interactions with the AI assistant.

Implement YAML-based conversation history persistence in Genesis AI, using a unique ID for each session.


The system uses trigger words ('claude', 'cloud', 'sonnet', 'sonny') to prevent accidental execution of commands.

Reduces unintended actions and improves the reliability of the voice interface.

Implement a configurable trigger word system in Genesis AI, allowing users to define their preferred trigger words.


GPT-4.1-mini is used to compress verbose Claude Code output into a more natural and concise format suitable for speech.

Improves the user experience by making the AI's responses more conversational and easier to understand.

Integrate a response compression module using a language model (GPT-4.1-mini or equivalent) to refine the AI's output for voice interaction.


RealtimeSTT, which wraps faster-whisper, is used for speech-to-text, offering a balance of speed and accuracy with local processing, eliminating API costs.

Provides a cost-effective and efficient solution for real-time speech transcription.

Utilize RealtimeSTT or a similar library based on faster-whisper for local speech-to-text processing in Genesis AI.


The system uses the Claude Code CLI as a subprocess (`claude -p`) to execute commands, capturing the output for further processing.

Enables seamless integration with Claude Code's agentic coding capabilities.

Implement a mechanism to execute Claude Code commands as subprocesses within Genesis AI, capturing and parsing the output.


The `--allowedTools` parameter is used to restrict the tools that Claude Code can access, enhancing security and controlling costs.

Reduces the risk of unintended actions and limits API usage.

Implement a tool access control mechanism in Genesis AI, allowing users to specify which tools the AI can utilize.


IndyDevDan's costs are dominated by Claude Code API usage, highlighting the importance of cost optimization strategies.

High API costs can limit the scalability and accessibility of the system.

Explore cost-effective alternatives to Claude Code API, such as local models or optimized prompting strategies.


VoiceMode MCP offers native integration with Claude Code, supports offline mode, and is actively maintained, presenting a polished alternative to IndyDevDan's approach.

Provides a more streamlined and potentially more robust solution for voice interaction with Claude Code.

Evaluate VoiceMode MCP as a potential integration option for Genesis AI, considering its features and maintenance status.


The system architecture consists of three main components: Ears (RealtimeSTT), Brain (Claude Code), and Voice (OpenAI TTS).

Provides a clear and modular design for building a voice-controlled AI assistant.

Adopt a similar modular architecture for Genesis AI, separating the speech-to-text, processing, and text-to-speech components.


The system can be run natively on Windows to bypass WSL2 audio issues, offering a simpler setup process.

Provides a more accessible and user-friendly installation experience for Windows users.

Ensure that Genesis AI can be run natively on Windows, providing clear instructions for installation and configuration.


IndyDevDan highlights that 'Compute equals success. The more you scale your compute, the more success you will have.'

Emphasizes the importance of computational resources for achieving optimal AI performance.

Prioritize access to sufficient computational resources (GPU, CPU) for Genesis AI to ensure optimal performance and scalability.


Multiple alternative voice-to-terminal tools exist, each with different STT, TTS, and Claude Code integration methods.

Highlights the diverse landscape of voice-controlled AI tools and the various approaches to integration.

Continuously monitor the ecosystem of voice-to-terminal tools to identify potential improvements and integration opportunities for Genesis AI.


The Claude Code is Programmable codebase is only ~700 lines of code, demonstrating the potential for a relatively simple implementation.

Shows that a functional voice-controlled AI assistant can be built with a manageable codebase.

Strive for a concise and maintainable codebase for Genesis AI, focusing on modularity and clear design principles.


The system uses OpenAI TTS for voice output, with the 'nova' voice being the default.

Provides a high-quality and customizable text-to-speech solution.

Integrate OpenAI TTS or a similar text-to-speech service into Genesis AI, allowing users to select their preferred voice.


The video demonstrates the ability to make code changes, read documentation, and implement new features entirely through voice commands.

Highlights the potential for voice-controlled AI to significantly enhance developer productivity.

Prioritize the development of voice-controlled features that enable code modification, documentation access, and feature implementation within Genesis AI.


The video mentions the Claude Max plan, suggesting a potential revenue model based on subscription access to Claude Code's capabilities.

Provides insights into potential pricing and packaging strategies for AI-powered coding tools.

Explore subscription-based revenue models for Genesis AI, offering different tiers of access to features and computational resources.


The system uses a plan-first approach, emphasizing the importance of detailed planning for effective prompting.

Highlights the value of structured prompting for achieving desired outcomes with AI models.

Incorporate a planning stage into the Genesis AI workflow, encouraging users to define clear goals and specifications before executing commands.


The video compares the system to Cursor, Windsurf, and Codex, suggesting a competitive landscape with varying capabilities.

Provides context for understanding the strengths and weaknesses of different AI-powered coding tools.

Conduct a thorough competitive analysis of AI-powered coding tools, identifying key differentiators and opportunities for Genesis AI.


The video demonstrates the ability to have the assistant merge READMEs and clean up files via voice commands.

Shows the potential for voice-controlled AI to automate routine tasks and improve code organization.

Develop voice-controlled features for Genesis AI that automate common code management tasks, such as file merging, cleanup, and organization.


The video mentions the use of UV (uvx) for dependency management and running the script, simplifying the setup process.

Streamlines the installation and execution of the system.

Investigate the use of UV or similar tools for dependency management and execution in Genesis AI, simplifying the setup process for users.


The video highlights the importance of solving microphone access issues in WSL2, providing several solutions.

Addresses a common challenge for users running the system in a WSL2 environment.

Provide comprehensive documentation and troubleshooting guides for resolving microphone access issues in WSL2 when using Genesis AI.


The 'Minimal Custom Build' example shows how to create a simplified voice-to-terminal bridge with custom trigger words.

Provides a starting point for building a Genesis-native voice assistant with tailored functionality.

Develop a Genesis-native voice assistant based on the 'Minimal Custom Build' example, incorporating custom trigger words and tailored functionality.


The RealtimeSTT library uses WebRTCVAD and SileroVAD for voice activity detection, improving the accuracy and efficiency of speech transcription.

Enhances the reliability of the speech-to-text component.

Evaluate and integrate voice activity detection techniques (e.g., WebRTCVAD, SileroVAD) into the Genesis AI speech-to-text pipeline.


The video mentions the use of OpenAI API keys for TTS and compression, requiring users to manage API keys.

Adds complexity to the setup process and potentially increases costs.

Explore options for reducing reliance on external API keys, such as using local models or providing managed API key services.


The video demonstrates the ability to create a web search script entirely through voice commands, showcasing the potential for rapid prototyping.

Highlights the power of voice-controlled AI for accelerating software development.

Develop voice-controlled features that enable rapid prototyping and development of new scripts and applications within Genesis AI.


The video mentions the use of a daemon process for the claude-ptt tool, suggesting a background process for continuous listening.

Enables a more seamless and responsive voice interaction experience.

Explore the use of background processes or services for continuous listening and voice command processing in Genesis AI.


The video highlights the importance of great planning for great prompting, suggesting a need for structured prompting techniques.

Improves the quality and effectiveness of AI responses.

Implement structured prompting techniques and tools within Genesis AI to guide users in creating effective prompts.


The video mentions the use of push-to-talk triggers in some tools (claude-whisper, claude-ptt), offering an alternative to continuous listening.

Provides a more controlled and privacy-conscious approach to voice interaction.

Offer push-to-talk as an alternative trigger mechanism for voice commands in Genesis AI.


The video mentions the use of MLX Whisper for Apple Silicon optimization in claude-whisper, highlighting the importance of platform-specific optimizations.

Improves performance and efficiency on specific hardware platforms.

Explore platform-specific optimizations for Genesis AI, such as using MLX Whisper on Apple Silicon devices.


The video mentions the use of local Kokoro TTS in VoiceMode, offering a fully offline text-to-speech option.

Provides a privacy-focused and cost-effective alternative to cloud-based TTS services.

Investigate and potentially integrate local TTS options, such as Kokoro, into Genesis AI to provide a fully offline text-to-speech capability.


The video mentions the use of the Claude Agent SDK in claude-whisper, suggesting a more direct integration with Claude Code.

Potentially offers a more efficient and flexible integration with Claude Code's capabilities.

Explore the use of the Claude Agent SDK for a more direct and potentially more efficient integration with Claude Code in Genesis AI.


The video mentions the use of desktop notifications in claude-whisper, providing a visual indication of AI activity.

Improves the user experience by providing clear feedback on AI actions.

Implement desktop notifications in Genesis AI to provide users with visual feedback on AI activity and progress.


The video mentions the use of auto-fallback between cloud and local backends in claude-ptt, providing resilience and flexibility.

Ensures continued functionality even in the absence of a network connection.

Implement auto-fallback mechanisms in Genesis AI to switch between cloud and local backends for key functionalities, ensuring resilience and flexibility.


The video mentions the use of a `/listen` slash command in listen-claude-code, providing a simple trigger mechanism for voice interaction.

Offers a convenient and intuitive way to initiate voice commands.

Explore the use of slash commands or similar mechanisms for initiating voice interaction within Genesis AI.


The video mentions the use of multi-language support in listen-claude-code, highlighting the importance of internationalization.

Expands the accessibility and usability of the system to a wider audience.

Prioritize multi-language support in Genesis AI, enabling users to interact with the system in their preferred language.


The video mentions the use of MCP tool integration in listen-claude-code, suggesting a modular and extensible architecture.

Enables easy integration of new tools and functionalities.

Adopt a modular and extensible architecture for Genesis AI, allowing for easy integration of new tools and functionalities via MCP or similar mechanisms.


The video mentions the use of a separate `listen` CLI tool in listen-claude-code, suggesting a separation of concerns.

Improves the maintainability and scalability of the system.

Consider separating the voice input and processing components of Genesis AI into separate modules or tools to improve maintainability and scalability.


The video demonstrates the ability to update allowed tools CLI parameters via voice command.

Allows for dynamic and voice-controlled security and cost management.

Implement voice commands to dynamically update the allowed tools CLI parameters, enabling voice-controlled security and cost management.


The video mentions the use of a 'plan-first' approach, where Claude creates a plan before implementing a task.

Improves the quality and reliability of the AI's output by ensuring a well-defined strategy.

Implement a 'plan-first' approach in Genesis AI, where the AI generates a plan before executing complex tasks.


Claude Code has a 'Plan Mode' (Shift+Tab x2) that restricts the agent to read-only operations, allowing it to analyze the codebase and create a plan before executing any changes.

Claude Code Plan Mode   The Senior Engineers Workflow (IndyDevDan)

Formalizes the planning phase, preventing premature actions and improving context window management.

Integrate Plan Mode into Genesis workflows by using Shift+Tab x2 before any non-trivial task involving Claude Code.


The system prompt for Claude Code includes an 'ExitPlanMode' tool, allowing the model to programmatically request exiting Plan Mode.

Enables more autonomous and sophisticated planning workflows where the agent can decide when it has gathered enough information.

Investigate how to leverage the 'ExitPlanMode' tool in Genesis agents for more dynamic planning.


Two workflows for Plan Mode: (A) Plan then Execute (quick tasks) and (B) Plan then Write Spec then Execute (recommended for mid-to-large features).

Provides a structured approach to using Plan Mode, with Workflow B emphasizing persistent, reviewable specifications.

Adopt Workflow B (Plan then Write Spec then Execute) as the standard for Genesis RWL stories and mid-to-large features.


Agents are ephemeral (stateless, context window gets blown away), making persistent specs crucial for long-term projects and collaboration.

Reinforces the importance of writing everything to files (MEMORY.md, specs, plans, KNOWLEDGE_GRAPH) in Genesis.

Continue prioritizing persistent storage of plans, specs, and knowledge in Genesis to avoid data loss and enable collaboration.


The 'Plan IS the Prompt' principle emphasizes that a well-crafted spec file is essentially a high-quality prompt that drives agent behavior.

Highlights the importance of investing time and effort in creating detailed and comprehensive specifications.

Allocate more time and resources to spec writing in Genesis projects, focusing on clarity, completeness, and testability.


Meta-prompting (writing a prompt that writes a prompt) is analogous to higher-order functions and enables recursive prompt composition.

Opens up possibilities for creating more complex and automated workflows in Genesis.

Explore and implement meta-prompting techniques in Genesis skills and custom slash commands to enable more sophisticated orchestration patterns.


Context window management is critical for agent performance, and Plan Mode helps load the context window with the right information.

Reinforces the importance of Genesis's 4-layer context defense system and the need for effective context priming.

Continue refining and optimizing Genesis's context management strategies, leveraging Plan Mode as a tool for context priming before major features.


The video demonstrates parallel agent execution from shared specs, where multiple agents work on isolated tasks based on a common specification.

Validates Genesis's existing approach of using agent teams and highlights the importance of spec quality for consistent output.

Focus on improving the quality and detail of specifications to ensure consistent and high-quality output from parallel agent teams in Genesis.


The video uses custom slash commands (e.g., `/infinite`, `/prime`) to automate tasks and load essential context.

Demonstrates the power of custom commands for streamlining workflows and enhancing agent capabilities.

Expand Genesis's skills registry with more spec-driven orchestration patterns and custom slash commands, including a `/plan` skill.


The presenter uses the phrase 'correct me if I'm wrong' to reduce sycophancy bias in the model and encourage honest feedback.

Improves the accuracy and reliability of agent responses by mitigating confirmation bias.

Incorporate 'correct me if I'm wrong' and other neutral question framing techniques into Genesis prompting guidelines for agent self-verification.


The presenter uses the phrase 'think hard' to trigger Claude's extended thinking/reasoning model.

Can improve the quality of complex outputs like architecture plans and PRDs.

Include 'think hard' in Genesis agent prompts when generating architecture plans, PRDs, or complex specifications.


The video highlights three essential directories for agentic coding: `specs/`, `source/`, and custom slash commands.

Provides a clear and organized structure for managing agent-driven projects.

Ensure that Genesis projects adhere to a similar directory structure, including `specs/` for specifications and `source/` for generated code.


The presenter recommends aiming for mid-to-large sized features to maximize the benefits of agentic coding.

Encourages a shift towards more ambitious and impactful projects.

Prioritize the development of larger, more complex features in Genesis projects to fully leverage the capabilities of agentic coding tools.


Gemini 2.5 Flash Native Audio processes audio directly, skipping speech-to-text conversion, resulting in more natural-sounding voice agents.

The Gemini Voice Gold Rush   How This Trend Is Being Turned Into Revenue (Nick Ponte)

Improved voice quality and reduced latency compared to traditional voice AI systems.

Continue leveraging Gemini's native audio processing in AIVA and highlight this advantage in marketing materials.


Gemini 3 Pro allows for faster agent creation through natural language prompting.

Reduced development time and increased accessibility for creating voice agents.

Evaluate Gemini 3 Pro for streamlining agent creation within Genesis AI Studio or similar internal tools.


The agency model for voice agents involves a setup fee and a monthly retainer.

Generates recurring revenue and allows for scaling the business.

Validate ReceptionistAI pricing against Ponte's recommended range of $500-$3,000/mo and adjust if necessary.


Undercharging for voice agent services makes it difficult to scale.

Limits revenue potential and hinders business growth.

Ensure pricing reflects the value provided and allows for sustainable growth.


Focusing on a specific industry niche allows for specialization and higher pricing.

Increased credibility and faster deal closures.

Expand niche focus to dental/medical/real estate verticals, in addition to existing tradie focus.


Businesses are willing to pay for voice agents that solve specific problems, such as customer service automation, appointment scheduling, and lead qualification.

Increased revenue and customer satisfaction.

Develop use case-specific marketing materials and pricing for each service.


Google AI Studio is a no-code platform for creating voice agents.

Simplified agent creation process and increased accessibility.

Evaluate Google AI Studio for potential integration or inspiration for Genesis's agent creation tools.


GoHighLevel (GHL) is a recommended business platform for managing voice agent services.

Streamlined business operations and improved customer management.

Leverage existing GHL integration and explore additional features for managing voice agent services.


Marketing should focus on business outcomes (more revenue, more time, less headaches) rather than technical specifications.

Increased customer engagement and higher conversion rates.

Overhaul marketing language for Talking Widget and ReceptionistAI to emphasize business outcomes.


Building a community (e.g., Facebook group) can provide social proof and support for AI agency owners.

Increased brand awareness and customer loyalty.

Consider launching a Genesis/Sunaiva Facebook group for AI agency owners.


Ponte's pricing framework includes setup fees ranging from $1,500 to $5,000 and monthly retainers ranging from $300 to $3,000.

Provides a benchmark for pricing voice agent services.

Compare Genesis's Talking Widget and ReceptionistAI pricing to Ponte's framework and adjust as needed to remain competitive and value-driven.


Ponte uses an AI avatar for content marketing.

Increased content creation efficiency and brand consistency.

Explore using an AI avatar for Sunaiva marketing videos.


Genesis's Bloodstream architecture provides agents with persistent memory, a feature Ponte's agents lack.

Differentiates Genesis's agents and provides a competitive advantage.

Highlight persistent memory capabilities in marketing materials and sales pitches.


Ponte emphasizes the reliability and trust associated with using Google's technology.

Increased customer confidence and adoption.

Leverage the Google brand in marketing materials and sales pitches to build trust.


Ponte recommends a 4-step sales strategy: create a Google AI Studio account, pick a target market, create a simple offer, and reach out to businesses.

Provides a structured approach to sales and marketing.

Adapt and implement Ponte's sales strategy for Genesis's voice agent services.


The video highlights the importance of selling a monthly service rather than a one-time setup.

Creates a stable and predictable revenue stream.

Continue to prioritize monthly subscription models for Genesis's voice agent services.


Telnyx is a better alternative to Twilio for the Australian market.

Improved performance and cost-effectiveness in the Australian market.

Continue using Telnyx for Australian clients and explore potential benefits in other markets.


Create an ROI calculator to demonstrate the cost savings of using a voice agent compared to hiring a receptionist.

Quantifiable value proposition for potential customers.

Build a simple ROI calculator for Talking Widget / ReceptionistAI.


Create vertical-specific landing pages with industry-specific language and scenarios.

Improved targeting and higher conversion rates.

Create niche landing pages for dental, legal, HVAC, and real estate verticals.


Emphasize the 24/7 availability of voice agents as a competitive advantage.

Attract customers who need after-hours support.

Position 24/7 capability prominently in marketing materials.


Position multilingual support as a premium feature for diverse markets.

Increased revenue from customers who need multilingual support.

Upsell 70+ language support as a premium feature.


Sign up for Deep Think API access via the waitlist form.

Gemini 3 Deep Think Is INCREDIBLE   Worlds Greatest AI Model EVER (WorldofAI)

Potential to supercharge the Genesis execution layer with Deep Think's reasoning capability for complex engineering and coding tasks.

Sign up for the Deep Think API waitlist using sunvision07@gmail.com.


Verify if current Ultra subscription grants Deep Think access in Gemini App.

Immediate access to Deep Think capabilities if already subscribed to Google AI Ultra.

Check gemini.google.com > Tools > Deep Think to see if Deep Think is accessible.


Add Deep Think as a premium tier for complex architecture/design tasks in the Genesis Gemini executor.

Enhance Genesis's ability to handle complex engineering problems and architectural reasoning.

Modify the Genesis Gemini executor to route complex architecture/design tasks to Deep Think via the Gemini API when available.


Implement a pattern: Flash for volume work, Deep Think for architectural reasoning.

Optimize resource allocation by using Flash for routine tasks and Deep Think for complex problem-solving.

Develop a task routing mechanism that automatically assigns tasks to Flash or Deep Think based on complexity and requirements.


Explore using Deep Think for Genesis code review, architecture validation, and complex module design.

Improve code quality and system architecture by leveraging Deep Think's elite competitive programming skills and architectural thinking.

Experiment with using Deep Think to review existing Genesis code, validate system architecture, and design complex modules.


Monitor Deep Think's pricing and access tiers for potential cost optimization.

Ensure cost-effectiveness when integrating Deep Think into Genesis workflows.

Track changes in Google AI Ultra subscription pricing and API access options to identify opportunities for cost savings.


Update the KNOWLEDGE_GRAPH/entities/gemini_ultra_capabilities.jsonl with Deep Think entries.

Improve the knowledge graph with up-to-date information about Deep Think's capabilities.

Add Deep Think's benchmark data and capabilities to the KNOWLEDGE_GRAPH/entities/gemini_ultra_capabilities.jsonl file.


Deep Think outperforms GPT-5 on 2D SVG generation.

Deep Think is a better choice for SVG generation tasks than GPT-5.

Prioritize Deep Think over GPT-5 for SVG generation tasks within Genesis.


Deep Think's ability to create functional Minecraft clones and macOS clones demonstrates strong architectural understanding and code generation capabilities.

This showcases potential for complex system design and implementation within Genesis.

Explore using Deep Think for generating architectural blueprints or functional prototypes of new Genesis features.


Deep Think achieves 84.6% on ARC-AGI-2, surpassing human baseline, indicating genuine novel problem-solving ability.

Deep Think can potentially handle novel architecture challenges that other models fail at.

Test Deep Think on challenging, novel architectural problems within Genesis to assess its problem-solving capabilities.


Claude-Mem uses a PostToolUse hook to automatically capture tool executions and store them in memory.

Claude Code With UNLIMITED Memory   Solves Claudes Memory Problem (WorldofAI)

Improved memory capture and context retention.

Implement automatic observation capture in Genesis's PostToolUse hook.


Claude-Mem employs a 3-layer retrieval pattern (search -> timeline -> get_observations) for efficient token usage.

Reduced token consumption during memory retrieval.

Implement progressive disclosure in Bloodstream MCP using a 3-layer retrieval pattern.


Claude-Mem injects relevant context before Claude processes each prompt using a UserPromptSubmit hook.

Improved context awareness and response quality.

Add a UserPromptSubmit hook to Genesis for per-prompt memory injection.


Claude-Mem compresses observations via semantic summarization, achieving a 70% reduction in size.

Reduced storage requirements, faster search, and lower token costs.

Implement semantic compression before memory storage in Genesis.


Claude-Mem claims up to 95% token savings by avoiding re-explaining context.

Significant reduction in token usage, validating the Bloodstream Memory vision.

Benchmark and validate the token savings potential of Genesis's Bloodstream Memory.


Claude-Mem exposes memory functionality through 5 MCP tools (search, timeline, get_observations, save_memory, __IMPORTANT).

Provides a structured and accessible interface for memory interaction.

Study Claude-Mem's MCP tool design and consider incorporating similar tools into Genesis's Bloodstream MCP.


Claude-Mem uses a local SQLite database for storage, which is not compatible with Genesis's distributed architecture.

Incompatible storage solution for Genesis.


Claude-Mem is an open-source plugin for Claude Code that provides persistent memory across sessions.

Addresses Claude's memory limitations and improves output quality.

Monitor Claude-Mem's development and consider it as a lightweight complement for solo Claude Code sessions.


Claude-Mem uses ChromaDB with all-MiniLM-L6-v2 embedding model for vector search.

Enables semantic search over stored memories.

Evaluate all-MiniLM-L6-v2 embedding model for Genesis's Qdrant integration.


Claude-Mem includes an OpenClaw integration for notification feeds (Telegram/Discord/Slack).

Consider integrating similar notification feeds into Genesis for improved user awareness.