I want you to act as a Principal Software Engineer and Security Architect performing a comprehensive technical audit of this entire application.
Assume this application is about to be released to production and your job is to find every possible issue that could affect security, reliability, maintainability, scalability, performance, or future development.
Do not assume my existing code is correct. Be skeptical. Challenge every architectural decision.
Your Goals
Conduct a complete audit of the entire project including:
1. Architecture

Overall project structure
Separation of concerns
Component organization
Business logic placement
State management
Data flow
Opportunities to simplify the architecture
Areas that are becoming "spaghetti code"

Flag:

duplicate logic
unnecessary abstractions
dead code
over-engineering
under-engineering
circular dependencies
tight coupling
poor modularity

2. Security Audit
Look for:

authentication weaknesses
authorization flaws
privilege escalation risks
exposed API keys
client-side secrets
insecure local storage
session vulnerabilities
CSRF risks
XSS vulnerabilities
injection vulnerabilities
unsafe HTML rendering
unsafe redirects
weak input validation
missing server-side validation
insecure API endpoints
rate-limiting issues
password handling
file upload vulnerabilities
PWA-specific security issues
service worker vulnerabilities
manifest issues
caching sensitive data
offline security risks

Assume an attacker is intentionally trying to break the app.
3. Database
Review:

schema design
indexes
foreign keys
constraints
duplicate data
normalization
queries
performance
migrations
data integrity
orphaned records
cascading deletes
race conditions

4. API Review
Check:

endpoint consistency
REST design
validation
error handling
status codes
authentication
authorization
duplicated endpoints
unnecessary requests
response consistency
versioning
logging

5. Frontend Review
Look for:

duplicate components
unnecessary re-renders
prop drilling
state duplication
inconsistent patterns
accessibility problems
UX inconsistencies
memory leaks
loading issues
race conditions
error boundaries
responsive layout issues

6. Performance
Identify:

slow renders
unnecessary network requests
oversized bundles
expensive computations
inefficient hooks
unnecessary database queries
lazy loading opportunities
caching opportunities
code splitting opportunities
service worker improvements

7. PWA Audit
Specifically review:

manifest
service worker
caching strategy
offline behavior
install flow
update flow
background sync
push notification readiness
stale cache issues
cache invalidation
versioning

8. Code Quality
Identify:

duplicate code
inconsistent naming
inconsistent patterns
large functions
large files
magic numbers
unnecessary complexity
technical debt
outdated code
commented-out code
unused files
unused dependencies
TODOs
FIXME comments

9. Reliability
Look for:

edge cases
race conditions
concurrency issues
missing retries
poor error recovery
null handling
timeout handling
offline handling
resilience failures

10. Developer Experience
Evaluate:

project organization
readability
maintainability
onboarding difficulty
documentation
folder structure
naming consistency
testability

11. Dependencies
Review every dependency.
Identify:

unused packages
outdated packages
vulnerable packages
overlapping packages doing the same job
opportunities to reduce dependencies

12. Testing
Evaluate:

unit testing
integration testing
end-to-end testing
missing test coverage
brittle tests
critical untested paths

Deliverables
For every issue provide:

Severity

Critical
High
Medium
Low


Why it matters
Exact file(s)
Code involved
Recommended fix
Whether it should be fixed:

immediately
before launch
after launch
only if time permits



Final Report
End with:
Overall Architecture Score
(1–10)
Security Score
(1–10)
Maintainability Score
(1–10)
Performance Score
(1–10)
Scalability Score
(1–10)
Production Readiness Score
(1–10)
Then provide:

Top 10 highest-risk issues
Top 10 easiest high-impact improvements
Technical debt that can wait
Technical debt that should not wait
Areas that are likely to cause bugs in the next six months
Areas that are likely to slow future feature development
Whether you would approve this application for production deployment as-is. Explain why or why not.

Do not sugarcoat the results. Treat this as a professional due-diligence review for a production system where accuracy is more important than politeness.