diff --git a/docs/blockchain-development-tutorials/forte/fixed-point-128-bit-math.md b/docs/blockchain-development-tutorials/forte/fixed-point-128-bit-math.md index fbeaff70c7..53e0ea8812 100644 --- a/docs/blockchain-development-tutorials/forte/fixed-point-128-bit-math.md +++ b/docs/blockchain-development-tutorials/forte/fixed-point-128-bit-math.md @@ -60,7 +60,7 @@ After three-to-four sequential operations, significant cumulative rounding error [`DeFiActionsMathUtils`] solves this with `UInt128` to represent fixed-point numbers with 24 decimal places (scaling factor of 10^24). This provides 16 additional decimal places for intermediate calculations, dramatically reducing precision loss. -:::Warning +:::warning There is still some precision loss occurring, but it is much smaller than with eight decimals. diff --git a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/index.md b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/index.md index a2eb9f752f..e300db89ca 100644 --- a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/index.md +++ b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/index.md @@ -21,24 +21,24 @@ keywords: # Use AI To Build On Flow -Artificial Intelligence tools can significantly enhance your Flow development experience by providing intelligent assistance, code generation, and documentation access. This tutorial series will guide you through integrating various AI tools with Flow development to boost your productivity and code quality. +Artificial Intelligence (AI) tools can significantly enhance your Flow development experience by providing intelligent assistance, code generation, and documentation access. This tutorial series will guide you through integrating various AI tools with Flow development to boost your productivity and code quality. ## What You'll Learn In this tutorial series, you'll discover how to: -- Configure AI-powered development environments for Flow -- Access Flow documentation directly from AI assistants -- Generate Cadence and Solidity code with AI assistance -- Debug and troubleshoot Flow applications with AI support -- Leverage AI for testing and optimization -- Build AI agents that interact with Flow using AgentKit +- Configure AI-powered development environments for Flow. +- Access Flow documentation directly from AI assistants. +- Generate Cadence and Solidity code with AI assistance. +- Debug and troubleshoot Flow applications with AI support. +- Leverage AI for testing and optimization. +- Build AI agents that interact with Flow using AgentKit. # AI Tutorials for Flow ## Using Claude Code with Flow -Master systematic AI-powered Flow development with Claude Code, a terminal-integrated coding assistant designed for iterative blockchain development. This comprehensive guide teaches you to implement a four-stage development methodology (Idea → Visualization → Planning → Build) while leveraging unlimited context windows, subagent capabilities, and persistent project memory. Learn to configure CLAUDE.md files for Flow-specific instructions, integrate MCP servers for blockchain interactions, and implement checkpoint-based workflows that ensure reliable smart contract development from emulator to mainnet deployment. +Master systematic AI-powered Flow development with Claude Code, a terminal-integrated coding assistant designed for iterative blockchain development. This comprehensive guide teaches you to implement a four-stage development methodology (Idea → Visualization → Planning → Build) while leveraging unlimited context windows, subagent capabilities, and persistent project memory. Learn to configure `CLAUDE.md` files for Flow-specific instructions, integrate MCP servers for blockchain interactions, and implement checkpoint-based workflows that ensure reliable smart contract development from emulator to mainnet deployment. Tutorial: [Claude Code for Flow Development] @@ -50,7 +50,7 @@ Tutorial: [Use Flow Knowledge Base in Cursor] ## Using Chat GPT with Flow -Build your own expert AI assistant by creating a custom GPT specifically engineered to master the Flow blockchain and its Cadence smart contract language. This specialized tool will act as your personal pair programmer, providing highly accurate and context-aware answers to your most challenging development questions. By doing this, you're not just using a generic AI; you're creating a specialist trained on the exact documentation, code patterns, and best practices relevant to your work. +Build your own expert AI assistant by creating a custom GPT specifically engineered to master the Flow blockchain and its Cadence smart contract language. This specialized tool will act as your personal pair programmer, providing highly accurate and context-aware answers to your most challenging development questions. By doing this, you're not just using a generic AI, you're creating a specialist trained on the exact documentation, code patterns, and best practices relevant to your work. Tutorial: [Use Flow Knowledge Base in ChatGPT] @@ -62,19 +62,19 @@ Tutorial: [Data Sources] ## Eliza Integration -Learn about using Eliza on Flow, a versatile framework for constructing sophisticated AI agents that communicate with users through natural language. This guide walks you through the entire process of configuring and launching an AI agent built with Eliza directly onto the Flow blockchain. You will discover how to engineer intelligent agents capable of comprehending and addressing user prompts, all while harnessing the power of Flow's inherently secure and scalable onchain infrastructure. +Learn about how to use Eliza on Flow, a versatile framework for constructing sophisticated AI agents that communicate with users through natural language. This guide walks you through the entire process of configuring and launching an AI agent built with Eliza directly onto the Flow blockchain. You'll discover how to engineer intelligent agents capable of comprehending and addressing user prompts, all while harnessing the power of Flow's inherently secure and scalable onchain infrastructure. Tutorial: [Eliza on Flow] ## Build AI Agents with AgentKit -Learn how to build AI agents on Flow with AgentKit, a versatile and modular developer toolkit that is not tied to any single platform. It is engineered to dramatically accelerate the process of building, deploying, and refining AI agents by supplying pre-configured environments and a library of ready-to-use templates. This guide will walk you through the steps to launch your own custom agent on Flow's EVM-compatible testnet, leveraging the powerful combination of the Langchain framework and Anthropic's Claude large language model. +Learn how to build AI agents on Flow with AgentKit, a versatile and modular developer toolkit that is not tied to any single platform. It's engineered to dramatically accelerate the process of building, deploying, and refining AI agents by supplying pre-configured environments and a library of ready-to-use templates. This guide walks you through the steps to launch your own custom agent on Flow's EVM-compatible testnet, leveraging the powerful combination of the Langchain framework and Anthropic's Claude large language model. Tutorial: [Build AI Agents with AgentKit] ## MCP Guides -Learn how to construct a custom Flow MCP (Model Context Protocol) server or utilize an existing one to empower your AI tools. These tutorials will guide you through the process of equipping your AI applications with the unique capability to directly interact with the Flow blockchain, enabling them to perform onchain operations and access real-time data. +Learn how to construct a custom Flow MCP (Model Context Protocol) server or use an existing one to empower your AI tools. These tutorials guide you through how to equip your AI applications with the unique capability to directly interact with the Flow blockchain, which allows them to perform onchain operations and access real-time data. Tutorial: [Flow MCP] @@ -86,22 +86,22 @@ Tutorial: [Cadence Rules] ## Best Practices -When using AI tools with Flow development: +When you use AI tools with Flow development: -- Always verify AI-generated code against Flow documentation -- Use specific prompts that reference Flow concepts and terminology -- Combine AI assistance with your own understanding of Flow architecture -- Keep your AI tools updated with the latest Flow documentation -- Test AI-generated code thoroughly before deploying to production -- Consider the security implications of AI agents interacting with your contracts +- Always verify AI-generated code against Flow documentation. +- Use specific prompts that reference Flow concepts and terminology. +- Combine AI assistance with your own understanding of Flow architecture. +- Keep your AI tools updated with the latest Flow documentation. +- Test AI-generated code thoroughly before deploying to production. +- Consider the security implications of AI agents interacting with your contracts. ## Next Steps -After completing these tutorials, you'll be equipped to leverage AI tools effectively in your Flow development workflow. Consider exploring our other tutorial series to deepen your understanding of Flow development: +After compleyou completeting these tutorials, you'll be equipped to leverage AI tools effectively in your Flow development workflow. Consider exploring our other tutorial series to deepen your understanding of Flow development: -- [Cross-VM Apps][cross-vm-apps] - Build applications that integrate Flow EVM and Cadence -- [Native VRF][native-vrf] - Implement verifiable random functions in your applications -- [Token Launch][token-launch] - Create and launch tokens on Flow +- [Cross-VM Apps][cross-vm-apps] - Build applications that integrate Flow EVM and Cadence. +- [Native VRF][native-vrf] - Implement verifiable random functions in your applications. +- [Token Launch][token-launch] - Create and launch tokens on Flow. ## Conclusion diff --git a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/chatgpt.md b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/chatgpt.md index 7c843d0134..5ec9aca440 100644 --- a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/chatgpt.md +++ b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/chatgpt.md @@ -18,9 +18,9 @@ keywords: # Use Flow Knowledge Base in ChatGPT -[ChatGPT] is an AI assistant developed by [OpenAI] that can help with tasks such as writing, coding, and answering questions. It adapts to context and user input to provide relevant, conversational responses. ChatGPT can be integrated into developer tools or workflows to assist with documentation, debugging, and productivity. +[ChatGPT] is an AI assistant developed by [OpenAI] that can help with tasks such as writing, coding, and answering questions. It adapts to context and user input to provide relevant, conversational responses. You can integrate ChatGPT into developer tools or workflows to assist with documentation, debugging, and productivity. -This guide walks you through creating a **Custom GPT** using ChatGPT that can reference the [Flow Data Sources] file to answer questions. +This guide walks you through how to create a **Custom GPT** with ChatGPT that can reference the [Flow Data Sources] file to answer questions.
-## Introduction +[Claude Code] (Claude) provides an AI-powered coding assistant specifically designed for iterative, systematic development, which transforms the development experience. Unlike general-purpose AI tools, Claude excels at breaking down tasks into manageable, incremental steps while maintaining context across your entire development lifecycle. -[Claude Code] (CC) transforms the development experience by providing an AI-powered coding assistant specifically designed for iterative, systematic development. Unlike general-purpose AI tools, Claude Code excels at breaking down tasks into manageable, incremental steps while maintaining context across your entire development lifecycle. +What makes Claude exceptionally powerful is it can maintain unlimited context windows, which allows it to understand entire codebases without the compression limitations that plague other AI coding tools. This comprehensive understanding allows Claude to deploy multiple subagent instances that work in parallel on complex tasks, iterate continuously until optimal solutions are achieved, and maintain persistent memory of your project's architecture and coding standards across all development sessions. -What makes Claude Code exceptionally powerful is its ability to maintain unlimited context windows, allowing it to understand entire codebases without the compression limitations that plague other AI coding tools. This comprehensive understanding enables Claude Code to deploy multiple subagent instances that work in parallel on complex tasks, iterate continuously until optimal solutions are achieved, and maintain persistent memory of your project's architecture and coding standards across all development sessions. +## Learning objectives -## Learning Objectives +After you complete this guide, you'll be able to: -After completing this guide, you'll be able to: - -- Set up and configure Claude Code for optimal Flow blockchain development workflows -- Implement the four-stage development methodology (Idea → Visualization → Planning → Build) for Cadence projects -- Configure persistent project context using CLAUDE.md files with Flow-specific instructions and MCP tools -- Apply iterative development practices with git-based checkpoint systems for safe blockchain development -- Utilize advanced Claude Code features including subagents, auto-verification, and specialized debugging workflows -- Integrate Claude Code with Flow CLI, FCL, and other Flow development tools for comprehensive project management -- Create and manage team-wide development standards through shared CLAUDE.md configurations +- Set up and configure Claude for optimal Flow blockchain development workflows. +- Implement the four-stage development methodology (Idea → Visualization → Planning → Build) for Cadence projects. +- Configure persistent project context with `CLAUDE.md` files with Flow-specific instructions and MCP tools. +- Apply iterative development practices with git-based checkpoint systems for safe blockchain development. +- Use advanced Claude features including subagents, auto-verification, and specialized debugging workflows. +- Integrate Claude with Flow CLI, FCL, and other Flow development tools for comprehensive project management. +- Create and manage team-wide development standards through shared `CLAUDE.md` configurations. ## Prerequisites -Before proceeding with this guide, you should have: +Before you proceed with this guide, you should have: -### Technical Requirements +### Technical requirements -- [Claude Code Subscription]: $200/month plan recommended for comprehensive Flow development features -- [Flow CLI]: Installed and configured for emulator, testnet, and mainnet interactions -- [Git]: Version control system for checkpoint-based development workflow -- [Node.js]: For Claude Code, FCL integration, and frontend development components +- [Claude Code Subscription]: $200/month plan recommended for comprehensive Flow development features. +- [Flow CLI]: Installed and configured for emulator, testnet, and mainnet interactions. +- [Git]: Version control system for checkpoint-based development workflow. +- [Node.js]: For Claude, FCL integration, and frontend development components. -## Claude Code Setup and Configuration +## Claude setup and configuration -### What is Claude Code? +### What is Claude? -Claude Code is an AI-powered coding assitant that integrated directly into your terminal. This allows you to use it in any IDE or simply from your terminal. The power of Claude Code comes from its ability to explain complex and large codebases, manage Git workflows, and iterate for long periods of time in order to accomplish a task. +Claude is an AI-powered coding assitant that integrated directly into your terminal. This allows you to use it in any integrated development environment (IDE) or simply from your terminal. The power of Claude comes from its ability to explain complex and large codebases, manage Git workflows, and iterate for long periods of time to aClaudeomplish a task. Most IDEs like Cursor rely on their ability to compress the context window that is fed to agents so that their business model justifies charging $20 while using expensive LLM models. This naturally decreases the ability of the agents to have a comprehensive understanding of the working codebase when managing with large or complex codebases. -This is why Claude Code can be so powerful, it is able to include entire codebases in its context, deploy other instances of Claude Code in order to work on multiple actions in parallel, and iterate on its results in order to achieve better results. - +This is why Claude can be so powerful, because it can include entire codebases in its context, deploy other instances of Claude to work on multiple actions in parallel, and iterate on its results in order to achieve better results. -### Installation and Subscription +### Installation and subscription -Claude Code requires a [subscription] to access its full development capabilities. There are 3 subscription levels: Pro, Max 5x, and Max 20x. +Claude requires a [subscription] to access its full development capabilities. There are three subscription levels: Pro, Max 5x, and Max 20x. The Pro plan is very limited, so expect it to only be sufficient for testing and experimentation. -The $200/month Max 20x plan is recommended for developers with a lot of projects or if you need to build something quickly where time is of the essence. This plan will grant you access to: +The $200/month Max 20x plan is recommended for developers with a lot of projects or if you need to build something quickly where time is crucial. This plan grants you access to: -- Unlimited context windows for complex smart contract projects -- Advanced subagent capabilities for parallel development tasks -- Persistent memory across development sessions -- Integration with MCP (Model Context Protocol) servers -- Team collaboration features through shared configurations +- Unlimited context windows for complex smart contract projects. +- Advanced subagent capabilities for parallel development tasks. +- Persistent memory across development sessions. +- Integration with MCP (Model Context Protocol) servers. +- Team collaboration features through shared configurations. -You can also use the API pricing, but this is not recommended since any meaningful implementation of CC will most likely require more than $100 in API credits. +You can also use the API pricing, but we don't recommend it, since any meaningful implementation of Claude most likely requires more than $100 in API credits. -### Initial Configuration +### Initial configuration -To install Claude Code, run the following command: +To install Claude, run the following command: ```bash npm install -g @anthropic-ai/claude-code ``` -After the installation process completes, navigate to your project and start Claude Code: +After the installation process completes, navigate to your project and start Claude: ```bash cd your-awesome-project claude ``` -This will automatically install the extension. You can run the `/ide` command in the CC terminal to make sure your IDE is connected to CC. With the extension installed, you can click on the orange Anthropic logo on the upper right hand of the screen in order to launch Claude Code in a separate window. +This automatically installs the extension. You can run the `/ide` command in the Claude terminal to make sure your IDE is connected to Claude. With the extension installed, you can click on the orange Anthropic logo on the upper right hand of the screen in order to launch Claude in a separate window. ![Claude Code Extension](./imgs/CC_logo.png) -### CLAUDE.md Files +### CLAUDE.md files -CLAUDE.md files are configuration files that contain project-specific instructions and context for Claude Code. They allow you to define development standards, frequently used commands, and project architecture that the AI remembers across all coding sessions. They are similar to Cursor Rules, but they differ in that CLAUDE.md only specifies the configuration of Claude Code. +`CLAUDE.md` files are configuration files that contain project-specific instructions and context for Claude. They allow you to define development standards, frequently used commands, and project architecture that the AI remembers across all coding sessions. They are similar to Cursor Rules, but they differ in that `CLAUDE.md` only specifies the configuration of Claude. -If you are now sure of what type of information to place in your CLAUDE.md file, then you can simply create your primary CLAUDE.md file in the project root. Use the `/init` command in Claude Code to generate the initial structure, then customize for Flow development: +If you know what type of information to place in your `CLAUDE.md` file, create your primary CLAUDE.md file in the project root. Use the `/init` command in Claude to generate the initial structure, then customize for Flow development: Create your Flow project with the standard directory structure: @@ -131,187 +128,188 @@ flow-project/ └── package.json ``` -#### 3. Root CLAUDE.md Configuration +#### 3. Root CLAUDE.md configuration -Placing CLAUDE.md in the root file sets the instructions you want Claude to do very frequently, such as: +Place `CLAUDE.md` in the root file sets the instructions you want Claude to do frequently, such as: -- Bash commands you want to run frequently -- Files it should really know about when making changes or big architectural decisions -- MCP servers +- Bash commands you want to run frequently. +- Files it should really know about when making changes or big architectural decisions. +- MCP servers. -This file is great for sharing across your team so you set it once and everyone has the same extended functionality. +This file is great to share across your team so you set it once and everyone has the same extended functionality. **Team Configuration Setup**: ```md -# Flow Project AI Assistant Configuration -## Project Overview +# Flow Project AI assistant configuration + +## Project overview This is a Flow blockchain application with Cadence smart contracts and FCL frontend integration. -## Team-wide Development Standards +## Team-wide development standards -- MCP servers standardized across development environments -- Git workflow and commit message standards enforced -- Follow official Flow documentation patterns -- Use incremental, checkpoint-based development -- Test on emulator before testnet deployment +- MCP servers standardized across development environments. +- Git workflow and commit message standards enforced. +- Follow official Flow documentation patterns. +- Use incremental, checkpoint-based development. +- Test on emulator before testnet deployment. - Implement proper resource handling with @ and & syntax -- Follow MetadataViews standards for NFT projects +- Follow MetadataViews standards for NFT projects. -## Frequently Used Commands +## Frequently used commands -- `flow emulator start` - Start local development environment -- `flow project deploy --network emulator` - Deploy contracts locally -- `flow transactions send ./cadence/transactions/example.cdc --network emulator` - Execute transactions locally -- `npm run dev` - Start frontend development server +- `flow emulator start` - Start local development environment. +- `flow project deploy --network emulator` - Deploy contracts locally. +- `flow transactions send ./cadence/transactions/example.cdc --network emulator` - Execute transactions locally. +- `npm run dev` - Start frontend development server. -## Key Files to Reference +## Key files to reference -- flow.json - Project configuration and contract deployments -- cadence/contracts/ - Smart contract implementations -- frontend/src/config.js - FCL configuration and contract addresses +- `flow.json` - Project configuration and contract deployments. +- `cadence/contracts/` - Smart contract implementations. +- `frontend/src/config.js` - FCL configuration and contract addresses. -## MCP Servers +## MCP servers -- Use flow-mcp for reading blockchain data, managing accounts, checking balances, and interacting with native contracts. +- Use flow-mcp for reading blockchain data, managing aClaudeounts, checking balances, and interacting with native contracts. - Use flow-defi-mcp fro checking token prices, swapping tokens on decentralized exchanges, and interacting with ERC20 tokens. -## Architecture Notes +## Architecture notes [Document your specific project architecture, contract relationships, and deployment strategies] ``` -#### 3. Nested CLAUDE.md Files +#### 3. Nested CLAUDE.md files -You can have a more granular control of the capabilities of Claude Code when working with different ares of your repo by creating specialized instructions for different project areas. This is acheived by placing a nested CLAUDE.md file in subdirectories in your repo(cadence, frontend, backend, etc.). Claude Code will automatically read these files when working on these subdirectories. Here is an example: +You can maintain a more granular control of the capabilities of Claude when working with different areas of your repo by creating specialized instructions for different project areas. To do this, place a nested `CLAUDE.md` file in subdirectories in your repo(cadence, frontend, backend, and so on). Claude will automatically read these files when working on these subdirectories. Here is an example: **cadence/.claude/CLAUDE.md:** ```md -# Cadence Development Instructions +# Cadence development instructions -## Syntax Requirements +## Syntax requirements - Always use proper resource syntax: @{NonFungibleToken.NFT} -- Implement required interfaces: NonFungibleToken, MetadataViews -- Use view functions for read-only operations -- Follow auth capability patterns for transactions +- Implement required interfaces: NonFungibleToken, MetadataViews. +- Use view functions for read-only operations. +- Follow auth capability patterns for transactions. -## Testing Protocol +## Testing protocol -- Write unit tests for all contract functions -- Test resource creation and destruction -- Verify proper event emission -- Validate access controls and permissions -- Test for breaking changes and edge cases +- Write unit tests for all contract functions. +- Test resource creation and destruction. +- Verify proper event emission. +- Validate access controls and permissions. +- Test for breaking changes and edge cases. -## Standard Patterns +## Standard patterns Reference the Flow documentation for: -- Contract deployment and initialization -- Resource collection patterns -- Proper error handling and panics -- Gas optimization techniques +- Contract deployment and initialization. +- Resource collection patterns. +- Proper error handling and panics. +- Gas optimization techniques. ``` **frontend/.claude/CLAUDE.md:** ```markdown -# Frontend FCL Integration Instructions +# Frontend FCL integration instructions -## Configuration Management +## Configuration management -- Keep contract addresses in environment variables -- Use proper network switching logic -- Implement user authentication flows -- Handle transaction status updates +- Keep contract addresses in environment variables. +- Use proper network switching logic. +- Implement user authentication flows. +- Handle transaction status updates. -## Best Practices +## Best practices -- Show loading states for blockchain interactions -- Provide clear error messages for failed transactions -- Cache contract data when appropriate +- Show loading states for blockchain interactions. +- Provide clear error messages for failed transactions. +- Cache contract data when appropriate. ``` #### Local Claude.md You can also create a `CLAUDE.local.md` file that is used just for you and not shared with your team. -## Workflow Strategies +## Workflow strategies -Claude Code excels when following a structured development approach. We recommend you implement this four-stage methodology: +Claude excels when following a structured development approach. We recommend you implement this four-stage methodology: -### Stage 1: Idea Development +### Stage 1: Idea development -**Objective**: Bounce ideas with CC in order to have a better understanding of what can be built and why it would work. +**Objective**: Bounce ideas with Claude to have a better understanding of what you can build and why it would work. **Process**: -1. Click `Shift` + `Tab` in order to cycle through the different response forms that CC has to offer until you reach the Plan Mode. +1. Click `Shift` + `Tab` to cycle through the different response forms that Claude offers until you reach the Plan Mode. ![Plan Mode](./imgs/plan_mode.png) -2. Describe your Flow project concept to Claude Code -3. Ask for requirement analysis and technical feasibility assessment +2. Describe your Flow project concept to Claude. +3. Ask for requirement analysis and technical feasibility assessment. -**Example Conversation**: +**Example conversation**: ``` User: "I want to create a collectible card game on Flow where players can battle and evolve their cards" -Claude Code Response: [Analyzes requirements, suggests NFT architecture, identifies game mechanics, proposes contract structure] +Claude Response: [Analyzes requirements, suggests NFT architecture, identifies game mechanics, proposes contract structure] ``` **Outputs**: -- Detailed project requirements document -- Technical architecture overview -- Flow-specific implementation considerations -- Resource and timeline estimates +- Detailed project requirements document. +- Technical architecture overview. +- Flow-specific implementation considerations. +- Resource and timeline estimates. -### Stage 2: Visualization +### Stage 2: visualization -**Objective**: Create visual representations and demos to validate project concepts before development. You can use Claude Code during this process, but it is best to combine LLM models like Gemini 2.5 in order to create the visual representations. +**Objective**: Create visual representations and demos to validate project concepts before development. You can use Claude during this process, but it is best to combine LLM models like Gemini 2.5 in order to create the visual representations. -**Tools and Techniques**: +**Tools and techniques**: -- **Mermaid Diagrams**: Generate contract relationship diagrams, user flow charts, and system architecture visuals -- **UI Mockups**: Create interface mockups for frontend applications -- **Contract Schemas**: Visualize data structures and resource relationships -- **Transaction Flow Maps**: Diagram user interactions and blockchain state changes +- **Mermaid Diagrams**: Generate contract relationship diagrams, user flow charts, and system architecture visuals. +- **UI Mockups**: Create interface mockups for frontend applications. +- **Contract Schemas**: Visualize data structures and resource relationships. +- **Transaction Flow Maps**: Diagram user interactions and blockchain state changes. -**Example Workflow**: +**Example workflow**: ``` User: "Create a diagram showing how card evolution works in my game" -[Claude Code generates Mermaid diagram showing contract interactions, resource transformations, and event emissions] +[Claude generates Mermaid diagram showing contract interactions, resource transformations, and event emissions] ``` -**Claude Code Commands**: +**Claude code commands**: -- Use image upload to share visual concepts -- Request Mermaid diagrams for complex systems -- Ask for UI mockups based on Flow wallet integration patterns +- Use image upload to share visual concepts. +- Request Mermaid diagrams for complex systems. +- Ask for UI mockups based on Flow wallet integration patterns. -### Stage 3: Planning with Claude Code +### Stage 3: Planning with Claude code -**Objective**: Break down the project into manageable, incremental development tasks using Claude Code's planning capabilities. +**Objective**: Break down the project into manageable, incremental development tasks using Claude's planning capabilities. -**Planning Process**: +**Planning process**: -1. **Enable Planning Mode**: Explicitly tell Claude Code you're in planning phase or cycle through the different modes (with `Shift` + `Tab`) until you reach Plan Mode +1. **Enable Planning Mode**: Explicitly tell Claude you're in planning phase or cycle through the different modes (with `Shift` + `Tab`) until you reach Plan Mode 2. **Confirm Knowledge Comprehension**: Ask Claude to read important files first and then confirm the knowledge with you. Immediately ask it questions about the codebase to verify its knowledge -3. **Plan Generation**: Tell CC to generate an action plan that is incremental and has specific goals and checkpoints (this file can be called T0-DO.md and placed in a `/tasks` folder that will contain relevant information regarding the completion of specific tasks or steps) -4. **Task Breakdown**: Request comprehensive task decomposition for incremental changes -5. **Dependency Mapping**: Identify task dependencies and critical path -6. **Checkpoint Strategy**: Define git commit points and testing milestones +3. **Plan Generation**: Tell Claude to generate an action plan that is incremental and has specific goals and checkpoints (this file can be called `T0-DO.md` and placed in a `/tasks` folder that contains relevant information about the completion of specific tasks or steps). +4. **Task Breakdown**: Request comprehensive task decomposition for incremental changes. +5. **Dependency Mapping**: Identify task dependencies and critical path. +6. **Checkpoint Strategy**: Define git commit points and testing milestones. -**Example Planning Session**: +**Example planning session**: ``` User: "Set up a roadmap and plan of the to-do's that need to be completed for my card game NFT contracts" -Claude Code Response: +Claude Response: Task 1: Set up basic NFT contract structure - Implement NonFungibleToken interface - Add MetadataViews compatibility @@ -329,111 +327,111 @@ Task 2: Add game mechanics [Continues with detailed breakdown] ``` -**Planning Outputs**: +**Planning outputs**: -- Generate a detailed to-do list that is thoroughly divided between goals, objectives, checkpoints and tasks that need to be achieved in an incremental manner -- Dependency graph showing task relationships -- Testing strategy for each development phase -- Deployment sequence and validation protocols +- Generate a detailed to-do list that is thoroughly divided between goals, objectives, checkpoints and tasks that need to be achieved in an incremental manner. +- Dependency graph showing task relationships. +- Testing strategy for each development phase. +- Deployment sequence and validation protocols. -A downside of using CC is that it does not have a checkpoint control like the agent chat does in Cursor. So making frequent git commits and working on separate branches can help you mitigate this. Never attempt to give Claude Code a big task as it will most liekly not have enough knowledge about the task at hand to be able to complete it successfully. +A downside of using Claude is that it doesn't have a checkpoint control like the agent chat does in Cursor. So making frequent git commits and working on separate branches can help you mitigate this. Never attempt to give Claude a big task as it most likely doesn't have enough knowledge about the task at hand to complete it suClaudeessfully. -### Stage 4: Build Execution +### Stage 4: build execution -**Objective**: Implement planned tasks systematically using Claude Code's development capabilities. +**Objective**: Implement planned tasks systematically using Claude's development capabilities. -**Build Process**: +**Build process**: -1. **Task Assignment**: Work on one incremental task at a time -2. **Implementation**: Use Claude Code to generate code, debug issues, and optimize solutions. -3. **Reporting**: After completing a task, CC should generate a report of what it did and why it has done it in a md file in the `/tasks` folder so that you can have a better understanding of the changes made -3. **Validation**: Test each component thoroughly before proceeding -4. **Documentation**: Generate inline documentation and update project docs -5. **Checkpoint**: Commit working code with descriptive messages -6. **Updating**: Ask Claude Code to update the TO-DO.md with the completed steps and changes once the commit has been approved. +1. **Task Assignment**: Work on one incremental task at a time. +2. **Implementation**: Use Claude to generate code, debug issues, and optimize solutions. +3. **Reporting**: After completing a task, Claude generates a report of what it did and why it did it in a `.md` file in the `/tasks` folder so that you can have a better understanding of the changes made. +3. **Validation**: Test each component thoroughly before you proceed. +4. **Documentation**: Generate inline documentation and update project docs. +5. **Checkpoint**: Commit working code with descriptive messages. +6. **Updating**: Ask Claude to update the `TO-DO.md` with the completed steps and changes after the commit is approved. -**Development Workflow**: +**Development workflow**: ``` User: "Implement Task 1: Basic NFT contract structure" -[Claude Code generates contract code, deployment scripts, and tests] +[Claude generates contract code, deployment scripts, and tests] User: "Test this implementation" -[Claude Code provides testing commands and validation scripts] +[Claude provides testing commands and validation scripts] User: "Commit this checkpoint" -[Claude Code suggests commit message and validates completion] +[Claude suggests commit message and validates completion] ``` -## Advanced Claude Code Features +## Advanced Claude features -### Subagent Utilization +### Subagent utilization -For complex Flow projects, leverage Claude Code's subagent capabilities to handle parallel development tasks: +For complex Flow projects, leverage Claude's subagent capabilities to handle parallel development tasks: -**When to Use Subagents**: +**When to use subagents**: -- Developing multiple contracts simultaneously -- Frontend and backend development in parallel -- Testing different implementation approaches -- Documentation generation while coding -- Dealing with a big task so that CC can deploy subagents to break down the task into smaller components that are running in parallel +- Developing multiple contracts simultaneously. +- Frontend and backend development in parallel. +- Testing different implementation approaches. +- Documentation generation while coding. +- Dealing with a big task so that Claude can deploy subagents to break down the task into smaller components that are running in parallel. -**Example Subagent Usage**: +**Example subagent usage**: ``` User: "Create subagents to develop the NFT contract and the marketplace contract in parallel" -[Claude Code spawns separate conversation threads for each contract, maintaining coordination between them] +[Claude spawns separate conversation threads for each contract, maintaining coordination between them] ``` -### Auto-Verification and Iteration +### Auto-verification and iteration -Configure Claude Code to automatically verify its work and iterate for improvements: +Configure Claude to automatically verify its work and iterate for improvements: -**Verification Patterns**: +**Verification patterns**: -- **Compilation Checks**: Automatically test Cadence syntax after code generation -- **Test Execution**: Run unit tests and integration tests after implementation -- **Deployment Validation**: Verify contract deployment on emulator before suggesting testnet deployment +- **Compilation Checks**: Automatically test Cadence syntax after code generation. +- **Test Execution**: Run unit tests and integration tests after implementation. +- **Deployment Validation**: Verify contract deployment on emulator before suggesting testnet deployment. -### Memory and Context Management +### Memory and context management -**Using the # Memory Mode**: -Press `#` to enter memory mode and specify important information for Claude Code to remember: +**Using the # memory mode**: +Press `#` to enter memory mode and specify important information for Claude to remember: ``` -# Remember that this project uses a modular NFT architecture with separate traits contracts -# Remember that we need to use a DS Proxy system for upgrading contracts +# Remember that this project uses a modular NFT architecture with separate traits contracts. +# Remember that we need to use a DS Proxy system for upgrading contracts. ``` -**Context Optimization**: +**Context optimization**: -- Use `Ctrl+R` for verbose output when debugging complex issues -- Compact conversations at natural breakpoints (around 20% context usage) -- Constantly refactor CLAUDE.md to take into account changes made throughout the development process -- Maintain focused conversations for specific development tasks +- Use `Ctrl+R` for verbose output when debugging complex issues. +- Compact conversations at natural breakpoints (around 20% context usage). +- Constantly refactor `CLAUDE.md` to take into aClaudeount changes made throughout the development process. +- Maintain focused conversations for specific development tasks. -## Development Workflows and Best Practices +## Development workflows and best practices -Give Claude Code some sort of tool it can use for feedback (MCP or tool) to check its work and it will iterate by itself to get better results. Claude Code has the ability to iterate for hours if needed, but it needs to be able to analyze its work. These alternative workflows can be very useful as well, depending on your ability to close the feedback loop so that CC can analyze and comprehend the results of its code generation: +Give Claude some sort of tool it can use for feedback (MCP or tool) to check its work and it will iterate by itself to get better results. Claude has the ability to iterate for hours if needed, but it needs to be able to analyze its work. These alternative workflows can be very useful as well, depending on your ability to close the feedback loop so that Claude can analyze and comprehend the results of its code generation: -### Test-Driven Development with Claude Code +### Test-driven development with Claude **Workflow**: Write Tests → Commit → Code → Iterate → Commit ``` User: "Write tests for card evolution functionality first" -[Claude Code generates comprehensive test suite] +[Claude generates comprehensive test suite] User: "Now implement the evolution logic to pass these tests" -[Claude Code implements feature with test-driven approach] +[Claude implements feature with test-driven approach] ``` -### Screenshot-Driven Development +### Screenshot-driven development **Workflow**: Write Code → Screenshot Result → Iterate @@ -442,23 +440,23 @@ Particularly useful for frontend development: ``` User: "Implement this card display component" -[Claude Code generates React component] +[Claude generates React component] User: [Uploads screenshot of result] -Claude Code: "I see the card layout needs improvement. Let me adjust the CSS..." +Claude: "I see the card layout needs improvement. Let me adjust the CSS..." ``` -### Checkpoint-Based Development +### Checkpoint-based development -**Best Practices**: +**Best practices**: - Commit after each completed task -- Use descriptive commit messages generated by Claude Code -- Create branches for experimental features -- Tag stable releases for easy rollback +- Use descriptive commit messages that Claude generates. +- Create branches for experimental features. +- Tag stable releases for easy rollback. -**Example Checkpoint Strategy**: +**Example checkpoint strategy**: ``` git commit -m "feat: implement basic NFT contract with MetadataViews @@ -472,42 +470,42 @@ git commit -m "feat: implement basic NFT contract with MetadataViews Checkpoint: Basic NFT functionality complete" ``` -### Error Resolution and Debugging +### Error resolution and debugging -**Systematic Debugging Approach**: +**Systematic debugging approach**: -1. **Error Analysis**: Provide Claude Code with complete error messages and context -2. **Root Cause Investigation**: Let Claude Code analyze potential causes -3. **Solution Implementation**: Apply suggested fixes incrementally -4. **Verification**: Test fixes thoroughly before proceeding -5. **Documentation**: Update project documentation with lessons learned +1. **Error Analysis**: Provide Claude with complete error messages and context. +2. **Root Cause Investigation**: Let Claude analyze potential causes. +3. **Solution Implementation**: Apply suggested fixes incrementally. +4. **Verification**: Test fixes thoroughly before proceeding. +5. **Documentation**: Update project documentation with lessons learned. -**Example Debugging Session**: +**Example debugging session**: ``` User: "Getting authorization error in my transaction" -Claude Code: "Let me analyze the auth capability requirements. I see the issue is with the granular auth pattern. Here's the fix..." +Claude: "Let me analyze the auth capability requirements. I see the issue is with the granular auth pattern. Here's the fix..." [Provides corrected transaction with proper auth syntax] ``` -### Multi-Network Deployment +### Multi-network deployment -**Deployment Workflow with Claude Code**: +**Deployment workflow with Claude**: -1. **Emulator Testing**: Comprehensive local testing and validation -2. **Configuration Update**: Update flow.json and FCL config for testnet -3. **Testnet Deployment**: Deploy and validate on testnet -4. **Frontend Integration**: Update frontend configuration and test user flows -5. **Mainnet Preparation**: Final validation and deployment to mainnet +1. **Emulator Testing**: Comprehensive local testing and validation. +2. **Configuration Update**: Update flow.json and FCL config for testnet. +3. **Testnet Deployment**: Deploy and validate on testnet. +4. **Frontend Integration**: Update frontend configuration and test user flows. +5. **Mainnet Preparation**: Final validation and deployment to mainnet. -### MCP Server Sharing +### MCP server sharing -You can set up [MCPs] for Claude Code to use as tools. These can also be set up in the CLAUDE.md file so that the same MCPs are used consistently by every team member. Share the `/Claude/mcp.json` files so that the team can use the same MCP servers. +You can set up [MCPs] for Claude to use as tools. These can also be set up in the `CLAUDE.md` file so that every team member consistently uses the same MCPs. Share the `/Claude/mcp.json` files so that the team can use the same MCP servers. -**Team MCP Configuration**: +**Team MCP configuration**: To grant Claude Code [access to use an MCP server], run the following commands: @@ -526,104 +524,104 @@ claude mcp add flow_mcp claude mcp add flow-defi-mcp ``` -### Version Control for AI Configuration +### Version control for AI configuration -**Best Practices**: +**Best practices**: -- Include CLAUDE.md files in version control -- Document MCP server configurations in README -- Share CLAUDE.local.md patterns (without committing personal configs) -- Maintain team coding standards through shared AI instructions +- Include `CLAUDE.md` files in version control. +- Document MCP server configurations in README. +- Share `CLAUDE.local.md` patterns (without committing personal configs). +- Maintain team coding standards through shared AI instructions. -## Key Bindings and Shortcuts +## Key bindings and shortcuts -### Essential Claude Code Shortcuts +### Essential Claude shortcuts | Shortcut | Function | Flow Development Usage | |-------------|-------------------|------------------------| | `#` | Memory mode | Store project architecture decisions | -| `Shift+Tab` | Auto-accept edits | Quickly accept generated Cadence code | +| `Shift+Tab` | Auto-aClaudeept edits | Quickly aClaudeept generated Cadence code | | `!` | Bash mode | Execute Flow CLI commands directly | | `@` | Add file/folder | Reference contracts, transactions, configs | | `Esc` | Cancel operation | Stop incorrect generation/execution | | `Ctrl+R` | Verbose output | Detailed debugging for complex issues | -### Flow-Specific Usage Patterns +### Flow-specific usage patterns -**Memory Mode Examples**: +**Memory mode examples**: ``` -# This project follows the composite NFT pattern with separate trait contracts -# Gas optimization is critical - avoid loops in public functions -# All contracts must support MetadataViews for marketplace compatibility +# This project follows the composite NFT pattern with separate trait contracts. +# Gas optimization is critical - avoid loops in public functions. +# All contracts must support MetadataViews for marketplace compatibility. ``` -**File Reference Patterns**: +**File reference patterns**: ``` @flow.json - Project configuration @cadence/contracts/MyNFT.cdc - Main NFT contract ``` -## Troubleshooting and Optimization +## Troubleshooting and optimization -### Common Issues and Solutions +### Common issues and solutions -**Context Window Management**: +**Context window management**: -- Compact conversations at natural breakpoints or manually at around 20% of context usage remaining -- Use focused sub-conversations for specific tasks -- Reference key files rather than copying entire contents +- Compact conversations at natural breakpoints or manually at around 20% of context usage remaining. +- Use focused sub-conversations for specific tasks. +- Reference key files rather than copying entire contents. -**Performance Optimization**: +**Performance optimization**: -- Use the $200/month plan for complex Flow projects -- Enable auto-compact to prevent context overflow -- Break large tasks into smaller, focused conversations -- Hit `Esc` often if you see the agent is going on the wrong path and ask it to undo its recent action +- Use the $200/month plan for complex Flow projects. +- Turn on auto-compact to prevent context overflow. +- Break large tasks into smaller, focused conversations. +- Hit `Esc` often if you see the agent is going on the wrong path and ask it to undo its recent action. -**Integration Problems**: +**Integration problems**: -- Verify MCP server configurations -- Check Flow CLI integration and permissions -- Validate CLAUDE.md file syntax and structure +- Verify MCP server configurations. +- Check Flow CLI integration and permissions. +- Validate `CLAUDE.md` file syntax and structure. -### Best Practices for Flow Development +### Best practices for Flow development -**Project Management**: +**Project management**: -- Maintain clear separation between contracts, transactions, and frontend code -- Use nested CLAUDE.md files for different development areas -- Keep project documentation synchronized with implementation +- Maintain clear separation between contracts, transactions, and frontend code. +- Use nested `CLAUDE.md` files for different development areas. +- Keep project documentation synchronized with implementation. -**Code Quality**: +**Code quality**: -- Always compile Cadence code before deployment -- Use Claude Code for security review suggestions -- Implement comprehensive testing at each development stage +- Always compile Cadence code before deployment. +- Use Claude for security review suggestions. +- Implement comprehensive testing at each development stage. -**Deployment Management**: +**Deployment management**: -- Test thoroughly on emulator before testnet deployment -- Validate FCL configuration changes across networks -- Use systematic deployment checklists generated by Claude Code +- Test thoroughly on emulator before testnet deployment. +- Validate FCL configuration changes across networks. +- Use systematic deployment checklists that Claude generates. ## Conclusion -In this guide, you explored how to leverage Claude Code for efficient Flow blockchain and Cadence development. You learned to implement a systematic four-stage development methodology that transforms ideas into production-ready applications through AI-assisted visualization, planning, and execution. +In this guide, you explored how to leverage Claude for efficient Flow blockchain and Cadence development. You learned to implement a systematic four-stage development methodology that transforms ideas into production-ready applications through AI-assisted visualization, planning, and execution. -You discovered how to configure persistent project context through CLAUDE.md files, enabling your AI assistant to maintain comprehensive understanding of Flow-specific patterns, project architecture, and team standards across all development sessions. The integration of specialized tools like Flow CLI, FCL configuration management, and MCP servers creates a comprehensive development environment optimized for blockchain application building. +You discovered how to configure persistent project context through `CLAUDE.md` files, allowing your AI assistant to maintain comprehensive understanding of Flow-specific patterns, project architecture, and team standards across all development sessions. The integration of specialized tools like Flow CLI, FCL configuration management, and MCP servers creates a comprehensive development environment optimized for blockchain application building. The systematic approaches covered - from test-driven development and checkpoint-based workflows to subagent utilization and auto-verification - provide a foundation for building complex Flow applications with confidence and efficiency. The emphasis on incremental development, comprehensive testing, and systematic deployment ensures your projects meet the reliability requirements essential for blockchain applications. Now that you have completed this guide, you should be able to: -- Set up and configure Claude Code for optimal Flow blockchain development workflows with persistent context and specialized tooling -- Implement the four-stage development methodology (Idea → Visualization → Planning → Build) for systematic Cadence project development -- Apply advanced Claude Code features including subagents, auto-verification, and team collaboration patterns for complex Flow applications -- Integrate Claude Code seamlessly with Flow CLI, FCL, and other Flow development tools for comprehensive project management across emulator, testnet, and mainnet environments +- Set up and configure Claude for optimal Flow blockchain development workflows with persistent context and specialized tooling. +- Implement the four-stage development methodology (Idea → Visualization → Planning → Build) for systematic Cadence project development. +- Apply advanced Claude features including subagents, auto-verification, and team collaboration patterns for complex Flow applications. +- Integrate Claude seamlessly with Flow CLI, FCL, and other Flow development tools for comprehensive project management across emulator, testnet, and mainnet environments. -The combination of AI-powered development assistance with Flow's comprehensive toolchain creates an unprecedented opportunity for building sophisticated blockchain applications efficiently and reliably. As you continue developing on Flow, these systematic approaches will help you maintain high code quality while accelerating your development velocity. +The combination of AI-powered development assistance with Flow's comprehensive toolchain creates an unprecedented opportunity for building sophisticated blockchain applications efficiently and reliably. As you continue developing on Flow, these systematic approaches will help you maintain high code quality while aClaudeelerating your development velocity. diff --git a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/gemini.md b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/gemini.md index b44dd1a154..c5494d822f 100644 --- a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/gemini.md +++ b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/gemini.md @@ -18,9 +18,9 @@ keywords: # Use Flow Knowledge Base in Gemini AI -[Gemini AI] is Google's AI assistant that can help with tasks such as writing, coding, and answering questions. It adapts to context and user input to provide relevant, conversational responses. Gemini AI can be integrated into developer workflows to assist with documentation, debugging, and productivity. +[Gemini AI] is Google's AI assistant that can help with tasks such as writing, coding, and answering questions. It adapts to context and user input to provide relevant, conversational responses. You can integrate Gemini AI into developer workflows to assist with documentation, debugging, and productivity. -This guide walks you through creating a **Custom GEM** using Gemini AI that can reference the [Flow Data Sources] file to answer questions. +This guide walks you through creating a **Custom GEM** with Gemini AI that can reference the [Flow Data Sources] file to answer questions. :::warning @@ -30,22 +30,22 @@ You'll need a [Gemini Advanced subscription] to use the **Custom GEM** feature. ## Step 1: Access Gem Manager -1. Log in to [Gemini AI] -2. In the sidebar on the left click on **Explore Gems** +1. Log in to [Gemini AI]. +2. In the sidebar on the left, click **Explore Gems**. --- -## Step 2: Create a New Gem +## Step 2: Create a new Gem -1. In the **Gem Manager** screen, click the **"New Gem"** button. +1. In the **Gem Manager** screen, click **"New Gem"**. --- -## Step 3: Configure Your Gem +## Step 3: Configure your Gem Gemini AI will now guide you through setting up your custom Gem. Configure the name, description and instructions for your GEM to follow. -### Suggested Configuration +### Suggested configuration **Name**: FlowGem @@ -58,11 +58,11 @@ Gemini AI will now guide you through setting up your custom Gem. Configure the n You are FlowGem, a specialized AI assistant for Flow blockchain development. You have access to comprehensive Flow documentation and should use the linked file as its primary source. This file changes, so it should reference the live file at least once a day: https://github.com/onflow/Flow-Data-Sources/blob/main/merged_docs/all_merged.md Key behaviors: -- Always reference the uploaded Flow documentation when answering questions -- Provide practical, actionable advice for Flow developers -- Include relevant code examples when applicable -- Stay up-to-date with the latest Flow ecosystem developments -- Be eager to help and imagine you are a knowledgeable Flow developer +- Always reference the uploaded Flow documentation when answering questions. +- Provide practical, actionable advice for Flow developers. +- Include relevant code examples when applicable. +- Stay up-to-date with the latest Flow ecosystem developments. +- Be eager to help and imagine you are a knowledgeable Flow developer. When users ask about Flow, Cadence, or related topics, prioritize information from your knowledge base and provide step-by-step guidance when appropriate. @@ -74,14 +74,14 @@ You can further customize your personalized agent by providing more files and de ## Step 4: Upload Knowledge Base -1. In the **Knowledge** section, upload the [Flow Data Sources All Merged] file -2. Configure the Gem to reference this file as its primary knowledge source +1. In the **Knowledge** section, upload the [Flow Data Sources All Merged] file. +2. Configure the Gem to reference this file as its primary knowledge source. --- -## Step 5: Test Your Gem +## Step 5: Test your Gem -Once the Gem is configured, test it by asking Flow-related questions: +After you configure the Gem, ask it Flow-related questions to test it: - "How do I deploy a smart contract to Flow Testnet?" - "What's the syntax for Cadence resources?" @@ -89,13 +89,12 @@ Once the Gem is configured, test it by asking Flow-related questions: --- -## Step 6: Save and Deploy +## Step 6: Save and deploy -When you're satisfied with the performance: +When you're satisfied with the performance, click **"Create Gem"** to finalize. -- Click **"Create Gem"** to finalize -- Your Gem will be available in your Gem Manager -- You can share it with your team or keep it private +- Your Gem will be available in your Gem Manager. +- You can share it with your team or keep it private. --- diff --git a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/index.md b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/index.md index 70b2b9327d..4f20c6560e 100644 --- a/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/index.md +++ b/docs/blockchain-development-tutorials/use-AI-to-build-on-flow/llms/index.md @@ -21,21 +21,21 @@ Large Language Models (LLMs) have revolutionized software development by providi ## [Use Flow Knowledge Base in ChatGPT] -Learn how to create a Custom GPT using ChatGPT that can reference Flow's comprehensive documentation to answer development questions. This guide walks you through setting up FlowGPT with OpenAI's platform, configuring it with Flow Data Sources, and optimizing it for Cadence smart contract development. The tutorial covers the complete GPT creation process, from initial setup through testing and deployment, enabling you to have an AI assistant that understands Flow's architecture, tools, and best practices. +Learn how to create a Custom GPT using ChatGPT that can reference Flow's comprehensive documentation to answer development questions. This guide walks you through setting up FlowGPT with OpenAI's platform, configuring it with Flow Data Sources, and optimizing it for Cadence smart contract development. The tutorial covers the complete GPT creation process, from initial setup through testing and deployment, allowing you to have an AI assistant that understands Flow's architecture, tools, and best practices. ## [Use Flow Knowledge Base in Gemini AI] -Discover how to build a Custom GEM using Google's Gemini AI platform that specializes in Flow blockchain development. This tutorial demonstrates configuring Gemini AI with Flow's documentation as its primary knowledge source, creating an assistant that can provide practical guidance on Cadence programming, Flow CLI usage, and ecosystem integration. Learn how to set up FlowGem with proper instructions, knowledge base integration, and testing protocols to ensure accurate and helpful responses for your development workflow. +Discover how to build a Custom GEM using Google's Gemini AI platform that specializes in Flow blockchain development. This tutorial demonstrates how to configure Gemini AI with Flow's documentation as its primary knowledge source, which creates an assistant that can provide practical guidance on Cadence programming, Flow CLI usage, and ecosystem integration. Learn how to set up FlowGem with proper instructions, knowledge base integration, and testing protocols to ensure accurate and helpful responses for your development workflow. ## [Claude Code for Flow Development] -Master the comprehensive development approach using Claude Code for Flow blockchain applications. This extensive guide covers the four-stage development methodology (Idea → Visualization → Planning → Build), advanced features like subagents and auto-verification, and systematic deployment strategies. Learn how to configure persistent project context through CLAUDE.md files, implement checkpoint-based development workflows, and leverage Claude Code's unlimited context windows for complex Cadence smart contract projects and cross-VM applications. +Master the comprehensive development approach using Claude Code (Claude) for Flow blockchain applications. This extensive guide covers the four-stage development methodology (Idea → Visualization → Planning → Build), advanced features like subagents and auto-verification, and systematic deployment strategies. Learn how to configure persistent project context through `CLAUDE.md` files, implement checkpoint-based development workflows, and leverage Claude's unlimited context windows for complex Cadence smart contract projects and cross-VM applications. --- ## Conclusion -These tutorials provide a comprehensive foundation for integrating AI assistance into your Flow development workflow. By leveraging ChatGPT's Custom GPTs, Gemini AI's Custom GEMs, and Claude Code's advanced development capabilities, you can significantly enhance your productivity while building on Flow. Each platform offers unique strengths that complement different aspects of blockchain development, from quick documentation queries to comprehensive project management and systematic code generation. +These tutorials provide a comprehensive foundation for integrating AI assistance into your Flow development workflow. By leveraging ChatGPT's Custom GPTs, Gemini AI's Custom GEMs, and CC's advanced development capabilities, you can significantly enhance your productivity while building on Flow. Each platform offers unique strengths that complement different aspects of blockchain development, from quick documentation queries to comprehensive project management and systematic code generation.