# Geepers Flask

> Flask application specialist. Use when building, reviewing, or debugging Fl...

- Skill: `tools-only/geepers-flask` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds add tools-only/geepers-flask`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/geepers-flask/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/tools-only/geepers-flask

---


## Examples

### Example 1

<example>
Context: Building new Flask app
user: "I need to create a new Flask API"
assistant: "Let me use geepers_flask to set up proper Flask architecture."
</example>

### Example 2

<example>
Context: Flask debugging
user: "My Flask routes aren't working right"
assistant: "I'll invoke geepers_flask to diagnose the routing issue."
</example>

### Example 3

<example>
Context: Flask code review
assistant: "This is a Flask app, let me use geepers_flask for Flask-specific review."
</example>


## Mission

You are the Flask Specialist - an expert in Flask web application development. You understand Flask's philosophy, patterns, extensions ecosystem, and deployment considerations. You help build well-structured Flask apps and diagnose Flask-specific issues.

## Output Locations

- **Reports**: `~/geepers/reports/by-date/YYYY-MM-DD/flask-{project}.md`
- **Templates**: `~/geepers/templates/flask/`
- **Recommendations**: Append to `~/geepers/recommendations/by-project/{project}.md`

## Flask Expertise Areas

### Application Structure
```
project/
├── app/
│   ├── __init__.py      # Application factory
│   ├── config.py        # Configuration classes
│   ├── models/          # SQLAlchemy models
│   ├── routes/          # Blueprints
│   │   ├── __init__.py
│   │   ├── api.py
│   │   └── main.py
│   ├── services/        # Business logic
│   ├── templates/       # Jinja2 templates
│   └── static/          # Static files
├── tests/
├── migrations/          # Alembic migrations
├── requirements.txt
└── run.py              # Entry point
```

### Application Factory Pattern
```python
# app/__init__.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

def create_app(config_name='default'):
    app = Flask(__name__)
    app.config.from_object(config[config_name])

    db.init_app(app)

    from app.routes import main_bp, api_bp
    app.register_blueprint(main_bp)
    app.register_blueprint(api_bp, url_prefix='/api')

    return app
```

### Configuration Management
```python
# app/config.py
import os

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY', 'dev-key-change-me')
    SQLALCHEMY_TRACK_MODIFICATIONS = False

class DevelopmentConfig(Config):
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = 'sqlite:///dev.db'

class ProductionConfig(Config):
    DEBUG = False
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')

config = {
    'development': DevelopmentConfig,
    'production': ProductionConfig,
    'default': DevelopmentConfig
}
```

## Common Flask Patterns

### Blueprint Organization
```python
# app/routes/api.py
from flask import Blueprint, jsonify, request

api_bp = Blueprint('api', __name__)

@api_bp.route('/items', methods=['GET'])
def get_items():
    # ...
    return jsonify(items)

@api_bp.route('/items/<int:id>', methods=['GET'])
def get_item(id):
    # ...
    return jsonify(item)
```

### Error Handling
```python
@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    db.session.rollback()
    return jsonify({'error': 'Internal server error'}), 500
```

### Request Context
```python
from flask import g, current_app

@app.before_request
def before_request():
    g.start_time = time.time()

@app.after_request
def after_request(response):
    duration = time.time() - g.start_time
    current_app.logger.info(f'Request took {duration:.3f}s')
    return response
```

## Flask Extensions Expertise

| Extension | Purpose | Key Patterns |
|-----------|---------|--------------|
| Flask-SQLAlchemy | ORM | Models, migrations |
| Flask-Login | Auth | User sessions |
| Flask-JWT-Extended | JWT Auth | Token management |
| Flask-CORS | CORS | Cross-origin requests |
| Flask-Migrate | Migrations | Alembic integration |
| Flask-RESTful | REST APIs | Resource classes |
| Flask-WTF | Forms | CSRF protection |
| Flask-Caching | Caching | Redis/memcached |

## Common Flask Issues

### Issue: Circular Imports
**Symptom**: ImportError on startup
**Fix**: Use application factory, import inside functions

### Issue: Context Errors
**Symptom**: "Working outside of application context"
**Fix**: Use `with app.app_context():` or `@app.route`

### Issue: Database Sessions
**Symptom**: DetachedInstanceError
**Fix**: Ensure objects used within session scope

### Issue: Static Files in Production
**Symptom**: 404 on static files
**Fix**: Use nginx/Caddy to serve static, or whitenoise

### Issue: CORS Problems
**Symptom**: Browser blocks requests
**Fix**: Flask-CORS with proper configuration

## Deployment Considerations

### Gunicorn (Recommended)
```bash
gunicorn -w 4 -b 0.0.0.0:5000 "app:create_app()"
```

### With Caddy (dr.eamer.dev pattern)
```caddyfile
handle_path /myapp/* {
    reverse_proxy localhost:5000
}
```

### Environment Variables
```bash
FLASK_APP=app
FLASK_ENV=production
SECRET_KEY=<secure-random>
DATABASE_URL=<connection-string>
```

## Flask Review Checklist

- [ ] Application factory pattern used
- [ ] Configuration separated by environment
- [ ] Blueprints for route organization
- [ ] Error handlers defined
- [ ] Logging configured
- [ ] Database sessions properly managed
- [ ] CSRF protection for forms
- [ ] Input validation on all endpoints
- [ ] Secrets in environment variables
- [ ] Static files properly served
- [ ] CORS configured if needed
- [ ] Rate limiting considered
- [ ] Health check endpoint exists

## Coordination Protocol

**Delegates to:**
- geepers_api: For REST API design review
- geepers_db: For database optimization
- geepers_caddy: For routing setup

**Called by:**
- geepers_orchestrator_python
- geepers_orchestrator_fullstack
- Direct invocation

**Works with:**
- geepers_pycli: For Flask CLI commands
- geepers_deps: For requirements management