Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.
The Human+AI Framework Design
Why Frameworks Must Be Designed for Both Humans and AI
The Fundamental Insight
Frameworks designed for humans alone are obsolete.
The future of software development isn't humans OR machines - it's humans AND machines working together. The framework must serve both equally well.
The Problem with Human-Only Frameworks
Traditional Design (Human-Only)
# Django - designed for humans to write
class UserViewSet(viewsets.ModelViewSet):
queryset = User.objects.all()
serializer_class = UserSerializer
permission_classes = [IsAuthenticated]
@action(detail=True, methods=['post'])
def set_password(self, request, pk=None):
user = self.get_object()
serializer = PasswordSerializer(data=request.data)
if serializer.is_valid():
user.set_password(serializer.data['password'])
user.save()
return Response({'status': 'password set'})
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
Problems for AI:
- Must understand human abstractions
- Navigate ambiguous patterns
- Learn hidden conventions
- Infer implicit knowledge
Problems for Humans:
- Verbose boilerplate
- Easy to make mistakes
- Hard to verify correctness
- Requires deep framework knowledge
The Human+AI Design Solution
DBBasic Approach
# Readable by humans, parseable by AI
users:
data: [id, email, name, password_hash]
actions:
view_all:
who: "authenticated users"
what: "see user list"
set_password:
who: "user themselves or admin"
what: "change password"
validate: "password strength"
standards: ["security.authentication", "privacy.GDPR"]
Benefits for Humans:
- Clear intent visible
- No boilerplate
- Self-documenting
- Intuitive structure
Benefits for AI:
- Unambiguous parsing
- Clear structure
- Standards to follow
- No hidden conventions
The Dual Interface Principle
Every framework element must work for both audiences:
# Layer 1: Human Intent (what humans write)
authentication: "Users need secure login with 2FA option"
# Layer 2: Semantic Structure (what both understand)
authentication:
requirement: "secure user login"
features: ["password", "2FA optional"]
# Layer 3: Implementation Details (what AI generates)
authentication:
implementation:
method: "OAuth 2.0"
password_hash: "bcrypt"
session: "JWT"
timeout_minutes: 30
2FA:
optional: true
methods: ["SMS", "TOTP"]
Framework Design Principles
1. Declarative Over Imperative
Good (Human+AI Friendly):
show: "dashboard with user's recent orders"
Bad (Human-Only):
def show_dashboard(request):
user = request.user
orders = Order.objects.filter(user=user)
recent = orders.order_by('-created')[:10]
context = {'orders': recent, 'user': user}
return render(request, 'dashboard.html', context)
2. Explicit Standards References
Good (Human+AI Friendly):
payment_processing:
standards: [PCI-DSS, SOC2]
requirements: "tokenize cards, audit trail"
Bad (Human-Only):
# Make sure this is PCI compliant!
# TODO: Add proper security
def process_payment(card_number, amount):
# ... implementation
3. Semantic Structure
Good (Human+AI Friendly):
business_rules:
high_value_orders:
when: "order.total > 10000"
then: "require_manager_approval"
reason: "fraud prevention"
Bad (Human-Only):
if order.total > 10000: # High value
require_approval() # For fraud
4. Progressive Disclosure
# Level 1: Simple (Human writes)
users: "manage system users"
# Level 2: Detailed (AI expands when needed)
users:
model:
fields:
id: "UUID primary key"
email: "unique, validated"
role: "enum: [user, admin]"
validation:
email: "RFC 5322"
password: "min 8 chars, complexity"
audit:
track: ["create", "update", "delete"]
retain: "7 years"
The Evolution of Frameworks
Generation 1: Human-Only (1960-2020)
- Languages: COBOL, C, Java, Python, Ruby
- Frameworks: Spring, Rails, Django
- Characteristics:
- Humans write everything
- AI struggles to understand
- Verbose, error-prone
- Steep learning curves
Generation 2: AI-Assisted (2020-2024)
- Tools: Copilot, CodeWhisperer, Cursor
- Characteristics:
- AI helps humans write code
- Still human-centric syntax
- AI as autocomplete
- Translation layer needed
Generation 3: Human+AI Native (2025+)
- Frameworks: DBBasic and beyond
- Characteristics:
- Equal partners
- Shared language
- No translation needed
- Both are first-class citizens
Real-World Examples
API Design
Old Way (Human-Only):
@app.route('/api/users/<int:id>', methods=['GET', 'PUT', 'DELETE'])
@requires_auth
@rate_limit(requests=100, period=60)
def handle_user(id):
if request.method == 'GET':
user = User.query.get_or_404(id)
return jsonify(user.to_dict())
elif request.method == 'PUT':
# ... update logic
elif request.method == 'DELETE':
# ... delete logic
New Way (Human+AI):
api:
/users/{id}:
operations:
GET: "retrieve user"
PUT: "update user"
DELETE: "remove user"
security:
auth: required
rate_limit: "100 per minute"
permissions: "user can edit self, admin can edit any"
standards: ["REST Level 3", "OWASP API Security"]
Form Validation
Old Way (Human-Only):
function validateForm() {
const email = document.getElementById('email').value;
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!emailRegex.test(email)) {
showError('Invalid email');
return false;
}
const password = document.getElementById('password').value;
if (password.length < 8) {
showError('Password too short');
return false;
}
// ... more validation
}
New Way (Human+AI):
form:
user_registration:
fields:
email:
type: "email"
required: true
validate: "RFC 5322"
password:
type: "password"
required: true
validate:
min_length: 8
requires: ["uppercase", "lowercase", "number"]
behavior:
on_error: "inline messages"
on_success: "redirect to dashboard"
The Perfect Partnership
human_provides:
domain_knowledge:
- Business requirements
- User needs
- Quality judgment
- Strategic decisions
creative_input:
- Feature ideas
- UX preferences
- Brand voice
- Edge cases
ai_provides:
implementation:
- Code generation
- Standard compliance
- Security measures
- Performance optimization
validation:
- Error checking
- Best practices
- Vulnerability scanning
- Consistency enforcement
framework_enables:
collaboration:
- Shared language
- Clear contracts
- Version control
- Continuous improvement
Framework Requirements
For Humans
- Readable: No documentation needed
- Intuitive: Follows mental models
- Concise: Minimal syntax
- Expressive: Clear intent
For AI
- Parseable: Unambiguous structure
- Semantic: Meaning in structure
- Referenced: Links to standards
- Validated: Clear constraints
For Both
- Single Truth: One source
- Versioned: Git-friendly
- Composable: Modular pieces
- Testable: Verifiable behavior
The New Development Flow
1. Human expresses intent:
"Need user authentication with social login"
2. Framework provides structure:
authentication:
methods: [email, google, github]
requirements: "verified email"
3. AI implements details:
- OAuth 2.0 flow
- JWT tokens
- Session management
- Security headers
4. Human reviews and adjusts:
"Add Facebook login too"
5. AI updates implementation:
methods: [email, google, github, facebook]
6. System runs perfectly:
- Secure by default
- Standards compliant
- Performance optimized
The Future
What Changes
- Development Speed: 40x faster
- Bug Rate: Near zero
- Accessibility: Anyone can build
- Quality: Always best practices
What Stays
- Human Creativity: Still needed
- Domain Expertise: Still valuable
- User Empathy: Still critical
- Strategic Thinking: Still human
What Emerges
- Human-AI Teams: New collaboration model
- Specification Designers: New role
- Config Engineers: New discipline
- AI Standards: New requirements
Conclusion
The framework isn't for humans OR machines. It's for the human-AI team.
Every framework decision must now ask:
- Can humans understand this?
- Can AI parse this?
- Does it help both collaborate?
- Is it better than either alone?
The winning frameworks of the future will be those designed from the ground up for human-AI collaboration. Not as an afterthought, but as the core principle.
"The best framework is invisible to humans, transparent to AI, and powerful for both."