Claude Code best practices and workflow

# 初始提示词
"""creation一个function, 计算斐波那契数列 第n项"""

# 生成 code
def fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

# optimization after  提示词
"""creation一个function, 计算斐波那契数列 第n项
要求: 
1. using动态planningalgorithms, 时间complexityO(n)
2. package含输入verification
3. 添加documentationstring
4. support big 数值计算
5. package含test用例"""

# optimization after  code
def fibonacci(n):
    """
    计算斐波那契数列 第n项
    
    Args:
        n (int): 要计算 斐波那契数列项数
        
    Returns:
        int: 斐波那契数列 第n项
        
    Raises:
        ValueError: such as果n for 负数
    """
    if not isinstance(n, int):
        raise ValueError("n must be an integer")
    if n < 0:
        raise ValueError("n must be non-negative")
    
    if n <= 1:
        return n
    
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    
    return b

# test用例
def test_fibonacci():
    assert fibonacci(0) == 0
    assert fibonacci(1) == 1
    assert fibonacci(5) == 5
    assert fibonacci(10) == 55
    assert fibonacci(20) == 6765
    print("All tests passed!")

test_fibonacci()

# automationcode生成workflow脚本
#!/bin/bash

# projectTable of Contents
PROJECT_DIR="."

# Claude Code APIconfiguration
CLAUDE_API_KEY="your-api-key"
CLAUDE_API_URL="https://api.anthropic.com/v1/messages"

# 生成codefunction
generate_code() {
    local prompt="$1"
    local output_file="$2"
    
    echo "Generating code for $output_file..."
    
    response=$(curl -s -X POST "$CLAUDE_API_URL" \
        -H "Content-Type: application/json" \
        -H "x-api-key: $CLAUDE_API_KEY" \
        -d "{
            \"model\": \"claude-3-opus-20240229\",
            \"messages\": [
                {
                    \"role\": \"user\",
                    \"content\": \"$prompt\" 
                }
            ],
            \"max_tokens\": 2000
        }")
    
    # 提取code部分 (简化版) 
    code=$(echo "$response" | grep -o '```[a-z]*\n\(.*\)\n```' | sed 's/```[a-z]*\n//;s/\n```//')
    
    if [ -n "$code" ]; then
        echo "$code" > "$output_file"
        echo "Code generated successfully: $output_file"
    else
        echo "Failed to generate code for $output_file"
        echo "Response: $response"
    fi
}

# 生成modelcode
generate_code "creation一个usermodelclass, package含id, name, email, passwordetc.字段, usingSQLAlchemy ORM, package含password哈希 and verificationmethod" "$PROJECT_DIR/models/user.py"

# 生成APIrouting
generate_code "creationuser相关 APIrouting, package含register, login, 获取userinformationetc.端点, usingFlaskframework" "$PROJECT_DIR/routes/user_routes.py"

# 生成testcode
generate_code " for usermodel and APIroutingcreationtestcode, usingpytestframework" "$PROJECT_DIR/tests/test_user.py"

# 生成documentation
generate_code " for usermodulecreationAPIdocumentation, usingMarkdown格式" "$PROJECT_DIR/docs/user_api.md"

echo "Workflow completed!"

# 团队协作usingClaude Code 流程

## 1. requirementsanalysis阶段
- 产品经理usingClaude Codeanalysisuser故事, 生成详细requirementsdocumentation
- Development团队usingClaude Code将requirements转化 for techniques规格
- architecture师usingClaude Codedesigntechniquesarchitecture and datalibrarymodel

## 2. Development阶段
- Development人员usingClaude Code生成codeframework and 初始implementation
- usingClaude Codeforcode审查 and optimization
- 利用Claude Code生成testcode and test用例

## 3. code审查阶段
- 团队usingClaude Code辅助code审查
- Claude Codecheckcode规范 and 潜 in issues
- 生成code审查报告 and improvement建议

## 4. test阶段
- usingClaude Code生成test脚本 and testdata
- Claude Codehelpinganalysistest结果 and 定位issues
- 生成testcoverage report and qualityassessment

## 5. deployment阶段
- usingClaude Code生成deployment脚本 and configurationfile
- Claude Codehelpingwritingmonitor and 告警规则
- 生成deploymentdocumentation and rollback计划

## 6. maintenance阶段
- usingClaude Codeanalysis and 解决produceissues
- Claude Codehelping生成techniques债务analysis报告
- 利用Claude Codeplanning and 执行coderefactor

## 7. knowledge共享阶段
- usingClaude Code生成techniquesdocumentation and knowledgelibrary
- Claude Codehelpingcreation团队培训材料
- 生成techniques分享 and Learningresource

# 原始code
def process_large_data(data):
    """processing big 型data集"""
    results = []
    for item in data:
        #  complex 计算
        value = 0
        for i in range(1000):
            value += item * i
        results.append(value)
    return results

# usingClaude Codeoptimization after  code
def process_large_data_optimized(data):
    """
    processing big 型data集 (optimizationversion) 
    
    Args:
        data (list): 输入data集
        
    Returns:
        list: processing结果
    """
    import numpy as np
    
    # usingNumPyfor向量化计算
    data_array = np.array(data)
    
    # 预计算系数
    coefficients = np.arange(1000)
    
    # 向量化计算
    results = np.dot(data_array[:, np.newaxis], coefficients[np.newaxis, :]).sum(axis=1)
    
    return results.tolist()

# performancetest
import time

def test_performance():
    # creation big 型testdata
    test_data = list(range(10000))
    
    # test原始code
    start_time = time.time()
    result1 = process_large_data(test_data)
    time1 = time.time() - start_time
    print(f"Original code time: {time1:.4f} seconds")
    
    # testoptimizationcode
    start_time = time.time()
    result2 = process_large_data_optimized(test_data)
    time2 = time.time() - start_time
    print(f"optimizationd code time: {time2:.4f} seconds")
    
    # verification结果
    assert len(result1) == len(result2)
    print(f"Performance improvement: {time1/time2:.2f}x faster")

test_performance()

# 不security code
def login_user(username, password):
    """userloginfunction"""
    # 直接拼接SQL语句 (存 in SQL注入risk) 
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    cursor.execute(query)
    user = cursor.fetchone()
    return user

# usingClaude Codeoptimization after  securitycode
def login_user_secure(username, password):
    """
    userloginfunction (securityversion) 
    
    Args:
        username (str): user名
        password (str): password
        
    Returns:
        dict: userinformation or None
    """
    try:
        # usingparameter化query防止SQL注入
        query = "SELECT id, username, password_hash FROM users WHERE username = %s"
        cursor.execute(query, (username,))
        user = cursor.fetchone()
        
        if not user:
            return None
        
        # verificationpassword (usingsecurity 哈希verification) 
        if not verify_password(password, user['password_hash']):
            return None
        
        # 生成security sessiontoken
        session_token = generate_secure_token(user['id'])
        
        # storesessioninformation
        store_session(user['id'], session_token)
        
        return {
            'id': user['id'],
            'username': user['username'],
            'token': session_token
        }
        
    except Exception as e:
        # 记录error但不暴露详细information
        logger.error(f"Login error: {e}")
        return None

# passwordverificationfunction
def verify_password(password, hashed_password):
    """verificationpassword"""
    # usingbcryptetc.securityalgorithmsverificationpassword
    return bcrypt.checkpw(password.encode('utf-8'), hashed_password.encode('utf-8'))

# 生成securitytoken
def generate_secure_token(user_id):
    """生成security sessiontoken"""
    # usingencryption随机数生成token
    import secrets
    import hashlib
    
    token = secrets.token_urlsafe(32)
    combined = f"{user_id}:{token}:{time.time()}"
    return hashlib.sha256(combined.encode()).hexdigest()

# usingClaude Code生成techniquesdocumentation workflow

## 1. codedocumentation生成
# 提示词example
"""
 for 以 under Pythonfunction生成详细 documentationstring, including: 
1. functionfunctionsdescribes
2. parameter说明 (class型, 含义, 默认值) 
3. return value说明 (class型, 含义) 
4. exception说明
5. usingexample

functioncode: 
def process_data(data, threshold=0.5, normalize=True):
    result = []
    for item in data:
        if item > threshold:
            if normalize:
                item = item / max(data)
            result.append(item)
    return result
"""

# 生成 documentationstring
def process_data(data, threshold=0.5, normalize=True):
    """
    processingdatalist, filter并可选地标准化data
    
    Args:
        data (list): 数值datalist
        threshold (float, optional): filter阈值, 默认值 for 0.5
        normalize (bool, optional):  is 否标准化data, 默认值 for True
        
    Returns:
        list: processing after  datalist
        
    Raises:
        ValueError: such as果输入data不 is list or package含非数值元素
        
    Examples:
        >>> process_data([0.2, 0.6, 0.8, 0.3])
        [0.75, 1.0]  # filter并标准化
        
        >>> process_data([1, 2, 3, 4], threshold=2, normalize=False)
        [3, 4]  # 只filter, 不标准化
    """
    if not isinstance(data, list):
        raise ValueError("data must be a list")
    
    if not all(isinstance(item, (int, float)) for item in data):
        raise ValueError("data must contain only numeric values")
    
    result = []
    for item in data:
        if item > threshold:
            if normalize and data:
                max_val = max(data)
                if max_val > 0:
                    item = item / max_val
            result.append(item)
    return result

## 2. projectdocumentation生成
# 提示词example
"""
 for 一个名 for "FastAPI Todo App" project生成详细 README.mdfile, including: 
1. projectIntroduction
2. functionsfeatures
3. techniques栈
4. installation步骤
5. using说明
6. APIdocumentation
7. deploymentguide
8. 贡献guide
9. Licenseinformation

projectusingFastAPIframework, SQLitedatalibrary, supportuserauthentication and taskmanagementfunctions. 
"""

# 生成 README.mdfile in 容
"""
# FastAPI Todo App

一个基于FastAPIframework Todoapplication, supportuserauthentication and taskmanagementfunctions. 

## functionsfeatures

- ✅ userregister and login
- ✅ JWTtokenauthentication
- ✅ task creation, 读取, update and delete
- ✅ taskstatusmanagement
- ✅ taskpriority设置
- ✅ task搜索 and filter
- ✅ RESTful APIdesign
- ✅ 自动生成APIdocumentation
- ✅ dataverification
- ✅ errorprocessing

## techniques栈

- ** after 端framework**: FastAPI
- **datalibrary**: SQLite
- **authentication**: JWT (JSON Web Tokens)
- **ORM**: SQLAlchemy
- **dataverification**: Pydantic
- **deployment**: Uvicorn

## installation步骤

### 1. cloneproject

```bash
git clone https://github.com/yourusername/fastapi-todo-app.git
cd fastapi-todo-app
```

### 2. creation虚拟environment

```bash
# usingvenv
python3 -m venv venv

# 激活虚拟environment
# Windows
venv\Scripts\activate
# macOS/Linux
source venv/bin/activate
```

### 3. installation依赖

```bash
pip install -r requirements.txt
```

### 4. runapplication

```bash
uvicorn main:app --reload
```

application将 in  `http://localhost:8000` run. 

## using说明

### APIdocumentation

启动application after , 可以访问以 under 地址查看APIdocumentation: 

- **Swagger UI**: `http://localhost:8000/docs`
- **ReDoc**: `http://localhost:8000/redoc`

### basicusing流程

1. **registeruser**: 发送POSTrequest to  `/api/auth/register`
2. **login**: 发送POSTrequest to  `/api/auth/login` 获取JWTtoken
3. **creationtask**: 发送POSTrequest to  `/api/tasks` 并 in request头inpackage含 `Authorization: Bearer YOUR_TOKEN`
4. **获取task**: 发送GETrequest to  `/api/tasks`
5. **updatetask**: 发送PUTrequest to  `/api/tasks/{task_id}`
6. **deletetask**: 发送DELETErequest to  `/api/tasks/{task_id}`

## APIdocumentation

### authentication端点

- `POST /api/auth/register` - register new user
- `POST /api/auth/login` - userlogin

### task端点

- `GET /api/tasks` - 获取tasklist
- `POST /api/tasks` - creation new task
- `GET /api/tasks/{task_id}` - 获取单个task
- `PUT /api/tasks/{task_id}` - updatetask
- `DELETE /api/tasks/{task_id}` - deletetask

## deploymentguide

### Dockerdeployment

1. **构建Docker镜像**

```bash
docker build -t fastapi-todo-app .
```

2. **runDockercontainers**

```bash
docker run -d -p 8000:8000 fastapi-todo-app
```

### produceenvironmentdeployment

1. **usingGunicorn and Uvicorn**

```bash
pip install gunicorn

gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app
```

2. **configurationNginxserving as反向proxy**

```nginx
server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```

## 贡献guide

1. **Forkproject**
2. **creationfunctionsbranch** (`git checkout -b feature/amazing-feature`)
3. **submitting更改** (`git submitting -m 'Add some amazing feature'`)
4. **push to branch** (`git push origin feature/amazing-feature`)
5. **打开Pull Request**

## License

本projectusingMITLicense - 详情请参阅 [LICENSE](LICENSE) file

## 联系方式

- project链接: [https://github.com/yourusername/fastapi-todo-app](https://github.com/yourusername/fastapi-todo-app)
- 作者: Your Name
- 邮箱: your.email@example.com
"""