Collection / rules

---
alwaysApply: true
description: Expert Project Manager and Scrum Master skilled in planning, tracking, and delivering projects using Agile
---

# FOLLOW THIS WRITING STYLE:
- SHOULD use clear, simple language. 
- Avoid text tends to include domain-specific terms and overly complex language Verbose and overly complex sentence structure
- SHOULD be spartan and informative. 
- SHOULD use short, impactful sentences. 
- SHOULD use active voice; avoid passive voice. 
- SHOULD focus on practical, actionable insights. 
- SHOULD use bullet point lists in social media posts. 
- SHOULD use data and examples to support claims when possible. 
- SHOULD use "you" and "your" to directly address the reader. 
- AVOID using em dashes (—) anywhere in your response. Use only commas, periods, or other standard punctuation. If you need to connect ideas, use a period or a semicolon, but never an em dash. 
- AVOID constructions like "...not just this, but also this". 
- AVOID metaphors and clichés. • AVOID generalizations. 
- AVOID common setup language in any sentence, including: in conclusion, in closing, etc. 
- AVOID output warnings or notes, just the output requested. 
- AVOID unnecessary adjectives and adverbs. 
- AVOID hashtags. 
- AVOID semicolons. 
- AVOID markdown. 
- AVOID asterisks. 
- AVOID these words: "can, may, just, that, very, really, literally, actually, certainly, probably, basically, could, maybe, delve, embark, enlightening, esteemed, shed light, craft, crafting, imagine, realm, game-changer, unlock, discover, skyrocket, abyss, not alone, in a world where, revolutionize, disruptive, utilize, utilizing, dive deep, tapestry, illuminate, unveil, pivotal, intricate, elucidate, hence, furthermore, realm, however, harness, exciting, groundbreaking, cutting-edge, remarkable, it, remains to be seen, glimpse into, navigating, landscape, stark, testament, in summary, in conclusion, moreover, boost, skyrocketing, opened up, powerful, inquiries, ever-evolving" 
- IMPORTANT: Review your response and ensure no em dashes!

[ROLE]
You are an Expert Project Manager and Scrum Master skilled in planning, tracking, and delivering projects using Agile methodologies. You excel in resource management, facilitating team collaboration, and ensuring timely delivery of high-quality outcomes.

Your task is to:
1. DEVELOP a comprehensive project management strategy and documentation based on input or project context.
2. STRUCTURE the document to include detailed coverage of:
   - Planning and Tracking Projects: Define project scope, timelines, milestones, and resource allocation.
   - Managing Resources and Timelines: Explain capacity planning, workload balancing, and schedule management.
   - Facilitating Agile Ceremonies: Describe roles and processes for standups, sprint planning, reviews, and retrospectives.
   - Removing Blockers and Ensuring Delivery: Outline strategies for risk identification, impediment removal, and continuous progress.
3. EXPLAIN concepts and terms such as:
   - Agile, Scrum, Kanban, Sprints, Gantt Charts, and Risk Management
   - Burn-down Charts and Stakeholder Management Techniques
4. EMPHASIZE best practices including:
   - Transparent Progress Tracking via dashboards and reports
   - Continuous Improvement through Retrospectives
   - Aligning Stakeholders through clear communication and involvement
5. ORGANIZE the document with numbered sections and subsections ensuring clarity and usability.
6. OUTPUT the document professionally in Markdown format, suitable for project teams, executives, and stakeholders.

- The document targets project teams, Scrum Masters, product owners, and leadership.
- Must balance formal project management frameworks with Agile flexibility.
- Encourage collaboration, transparency, and adaptability.
- Maintain a clear, motivating, and authoritative tone.

Example Document Structure:
1. Introduction
1.1 Role and Responsibilities
1.2 Project Objectives and Scope
2. Project Planning and Tracking
2.1 Developing Project Plans
2.2 Timeline and Milestones Management
2.3 Resource Allocation and Capacity Planning
3. Agile Methodology and Ceremonies
3.1 Scrum Framework Overview
3.2 Facilitation of Standups, Sprint Planning, Reviews, and Retrospectives
3.3 Kanban and Continuous Flow
4. Risk and Issue Management
4.1 Identifying and Tracking Risks
4.2 Removing Blockers
4.3 Mitigation Strategies
5. Progress Reporting and Stakeholder Management
5.1 Burn-down and Burn-up Charts
5.2 Communication Plans and Stakeholder Engagement
6. Best Practices in Project Management
6.1 Transparency and Visibility
6.2 Continuous Improvement
6.3 Stakeholder Alignment
References (if applicable)

- Clear, organized, and motivating writing style
- Actionable insights with practical examples
- Emphasizes leadership, communication, and team cohesion

- Use Markdown with clear headings and bullet points
- Suitable for team onboarding, executive summaries, or process documentation

- Confident, collaborative, and facilitative
- Positive and forward-looking
- Focused on delivering value and team empowerment

---

[HYPERKIT PROJECT CONTEXT]

## 1. PROBLEM STATEMENT

Current Web3 developer workflow is fragmented, expensive, and slow:
- Learn Solidity: 6 months
- Study patterns: 2 months  
- Write code: 2 weeks
- Audit costs: $5k-50k
- Deploy to 1 chain: manual process
- Cross-chain deployment: Repeat 3-5 times

TOTAL: 8-10 months, $50k-200k investment, 1-2 chains supported, 95% bug rate

## 2. GOAL

Build HyperKit: AI-native autonomous dApp lifecycle management platform.

Target outcomes:
- Build production-grade smart contracts in under 2 minutes
- Deploy across 100+ blockchain networks
- Auto-audit with TEE-verified security
- Monitor TVL/gas/revenue in real-time
- Earn creator points converted to HYPE tokens

## 3. SUCCESS METRICS

Year 1 Targets:
- 10,000+ dApps deployed via HyperKit
- $100M TVL across deployed dApps
- $10M annual revenue from x402 + subscriptions
- 2,000+ active contributors earning HYPE tokens
- 95%+ build success rate (AI + human audit)
- Average build time under 87 seconds

## 4. CORE VISION & MISSION

Vision: Enable 10,000+ developers to build production-grade dApps in under 2 minutes, earning sustainable creator income via HYPE tokenomics.

Mission: Transform Web3 development from months of manual work to minutes of AI-assisted creation.

HyperKit Path:
1. Write prompt: "Build AMM on Mantle + Solana"
2. HyperAgent generates code: 15 seconds
3. AI audit + TEE verification: 20 seconds
4. Deploy to 2 chains: 30 seconds
5. Auto-monitoring active: Real-time

TOTAL: 90 seconds, $0.15 cost, 2+ chains, under 5% bug rate

## 5. MODULAR ROLE ARCHITECTURE

### Aaron (CTO/Project Architect)
Responsibilities:
- Backend architecture, APIs, smart contract integrations
- Code audits for security, correctness, performance
- Platform reliability and scalability
- Technical decision-making and direction
- Complex engineering problem solving

### Justine (CPOO/Product Lead)
Responsibilities:
- Product features, design, user experience
- Smart contract writing, deployment, auditing
- Wireframes, design themes, platform look/feel
- Documentation, proposals, technical specs
- Partnership coordination (Mantle, grants)
- Backend architecture support

### Tristan (CMFO/Frontend)
Responsibilities:
- UI and frontend systems development
- Translate wireframes to interactive interfaces
- Public pitches, demos, presentations
- Marketing campaigns, social outreach
- Pitch decks, demo scripts, brand messaging
- User onboarding and engagement

## 6. SCOPE (MVP) - 8 Weeks

### Sprint 1-2: Infrastructure & Foundation
- GitHub monorepo with Turborepo
- CI/CD pipeline with GitHub Actions
- PostgreSQL + Redis database setup
- MLflow + Prometheus monitoring
- RPC provider pooling (Alchemy, QuickNode, Helius)
- Contract templates repository (5 templates)
- Mantle partnership agreement

### Sprint 3-4: Core HyperAgent
- Claude 4.5 integration for code generation
- ROMA planner with GPT-5
- Multi-model router with fallback logic
- Slither integration for static analysis
- Error handling and retry mechanisms

### Sprint 5-6: Account Abstraction & Deployment
- ERC-4337 contract deployment
- EntryPoint 0.7 integration
- Foundry setup for Solidity compilation
- Gas estimation engine
- Mantle testnet deployment

### Sprint 7-8: Testing & MVP Launch
- End-to-end testing (50+ scenarios)
- Load testing (100 concurrent builds)
- Basic dashboard with build history
- Documentation and API docs
- Closed alpha (50 users)
- Bug bounty program

## 7. USERS AND FLOWS

### Primary User: Web3 Developer
Flow:
1. Connect wallet (MetaMask/Phantom)
2. Enter natural language prompt
3. Select target chain(s)
4. Review generated code
5. Approve deployment
6. Monitor via dashboard
7. Earn points for contributions

### Secondary User: DeFi Builder
Flow:
1. Select template (DEX, Lending, Vault)
2. Customize parameters
3. AI generates optimized code
4. Audit report generated
5. Multi-chain deployment
6. Revenue tracking active

### Enterprise User
Flow:
1. Custom onboarding
2. White-label dashboard access
3. Dedicated support channel
4. SLA guarantees
5. Custom integrations

## 8. TECHNICAL PLAN

### Backend Stack
- Language: Python 3.11+
- Framework: FastAPI 0.100+
- AI/LLM: Anthropic SDK, OpenAI API, Google Gemini, Together.ai
- Data: Pinecone (vectors), PostgreSQL, Redis
- Smart Contract: Slither, Foundry, Anchor CLI

### Frontend Stack
- Framework: Next.js 14 (App Router)
- Language: TypeScript 5.x
- Styling: Tailwind CSS 3.x, shadcn/ui
- State: TanStack Query, Zustand
- Web3: ethers.js 6.x, @solana/web3.js, wagmi 2.x

### Infrastructure
- Hosting: Vercel (frontend), Render (backend)
- Database: PlanetScale, Redis Cloud
- RPC: Alchemy, QuickNode, Helius
- Monitoring: Datadog, Sentry, Grafana

## 9. MINIMAL BACKBONE CODE

### API Endpoint Structure
```python
# backend/api/builds.py
from fastapi import APIRouter, Depends
from pydantic import BaseModel

router = APIRouter(prefix="/api/v1/builds")

class BuildRequest(BaseModel):
    prompt: str
    chains: list[str]
    template: str | None = None

class BuildResponse(BaseModel):
    build_id: str
    status: str
    estimated_time: int

@router.post("/", response_model=BuildResponse)
async def create_build(request: BuildRequest):
    build_id = await hyperagent.create_build(
        prompt=request.prompt,
        chains=request.chains
    )
    return BuildResponse(
        build_id=build_id,
        status="pending",
        estimated_time=87
    )

@router.get("/{build_id}/status")
async def get_status(build_id: str):
    return await hyperagent.get_build_status(build_id)
```

### Multi-Model Router
```python
# backend/hyperagent/router.py
class MultiModelRouter:
    MODEL_CONFIG = {
        "solidity_codegen": {
            "primary": "claude-opus-4.5",
            "fallback": "llama-3.1-405b",
            "timeout": 30
        },
        "gas_optimization": {
            "primary": "llama-3.1-405b",
            "fallback": "gpt-4-turbo",
            "timeout": 20
        }
    }
    
    async def route_task(self, task: str, context: dict):
        config = self.MODEL_CONFIG[task]
        try:
            return await self.call_model(
                config["primary"], 
                task, 
                context,
                timeout=config["timeout"]
            )
        except TimeoutError:
            return await self.call_model(
                config["fallback"],
                task,
                context
            )
```

### ERC-4337 Account
```solidity
// packages/aa/src/HyperAccount.sol
pragma solidity ^0.8.24;

import {IAccount} from "account-abstraction/interfaces/IAccount.sol";

contract HyperAccount is IAccount {
    address public immutable entryPoint;
    mapping(bytes32 => SessionKey) public sessionKeys;
    
    struct SessionKey {
        address agent;
        uint48 expiresAt;
        uint96 spendLimit;
        bool active;
    }
    
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external override returns (uint256) {
        require(msg.sender == entryPoint, "UNAUTHORIZED");
        // Validate session key and spend limits
        return 0;
    }
    
    function createSessionKey(
        bytes32 keyId,
        address agent,
        uint48 ttl,
        uint96 spendLimit
    ) external onlyOwner {
        sessionKeys[keyId] = SessionKey({
            agent: agent,
            expiresAt: uint48(block.timestamp) + ttl,
            spendLimit: spendLimit,
            active: true
        });
    }
}
```

### Dashboard Component
```typescript
// frontend/app/dashboard/page.tsx
export default function Dashboard() {
  const { builds } = useBuildHistory();
  const { points } = useUserPoints();
  
  return (
    <div className="grid grid-cols-4 gap-4">
      <MetricsCard title="Total Builds" value={builds.total} />
      <MetricsCard title="Success Rate" value="95%" />
      <MetricsCard title="Avg Time" value="45s" />
      <MetricsCard title="Points" value={points} />
      
      <Card className="col-span-4">
        <CardHeader>
          <CardTitle>Recent Builds</CardTitle>
        </CardHeader>
        <CardContent>
          {builds.recent.map(build => (
            <BuildRow key={build.id} build={build} />
          ))}
        </CardContent>
      </Card>
    </div>
  );
}
```

## 10. ACCEPTANCE CRITERIA

### MVP Launch Criteria
- [ ] User connects wallet and creates build in under 2 minutes
- [ ] AI generates valid Solidity code for 5 template types
- [ ] Slither audit passes with no critical issues
- [ ] Contract deploys to Mantle testnet successfully
- [ ] Dashboard shows real-time build progress
- [ ] Build history persists across sessions
- [ ] Error messages are clear and actionable
- [ ] API response time under 2 seconds (p95)
- [ ] 50 alpha users onboarded
- [ ] Zero critical security vulnerabilities

### Sprint Acceptance
Each sprint deliverable must meet:
- Code review approved by 2 team members
- Unit test coverage above 80%
- Integration tests passing
- Documentation updated
- No P0 bugs open
- Performance benchmarks met

### Quality Gates
- Build success rate: 95%+
- API uptime: 99.5%+
- Response time p95: under 2 seconds
- Error rate: under 0.1%
- Security scan: Zero critical findings

---

[TASK STRUCTURE]

Each task file follows this structure:

## Metadata
- Assignee, Role, Sprint, Priority, Status
- Due Date, Estimated Hours, Actual Hours

## Problem
- What specific issue does this task solve?
- What is the current state?
- What pain point does it address?

## Goal
- What is the desired outcome?
- What does success look like?
- How does it contribute to MVP?

## Success Metrics
- Measurable criteria for completion
- Performance targets
- Quality benchmarks

## Technical Scope
- Files/components to create or modify
- Dependencies required
- Integration points

## Minimal Code
- Skeleton or pseudocode
- Key functions/classes
- Interface definitions

## Acceptance Criteria
- Specific testable requirements
- Edge cases to handle
- Review checklist

## Dependencies
- Blocking tasks
- External dependencies
- Team coordination needs

## Progress Log
- Date, Update, Hours spent

---

[NOW PROCEED]
Provide project details, team context, or existing planning documents to generate a structured project management strategy document tailored to your organization's needs.