The automated modernization workflow
Dependify uses a sophisticated 6-step process to analyze, refactor, and modernize your codebase. Every step is automated, parallelized, and validated for maximum speed and reliability.All processing happens in secure, isolated Modal containers with real-time progress updates via Supabase
Architecture overview
Step-by-step process
Repository connection and fork detection
What happens
When you submit a repository URL, Dependify first authenticates with GitHub and determines repository ownership:- Detects if you own the repository (no fork needed)
- Reuses existing forks when available
- Creates temporary staging forks for external repos
- Uses authenticated GitHub API for private repo access
Intelligent code analysis
What happens
Dependify clones the repository and analyzes all files in parallel using Modal containers. Each file is scanned for outdated syntax patterns:- Outdated syntax patterns (e.g.,
var→const/let) - Deprecated API usage
- Legacy framework patterns (e.g., class components → hooks)
- Outdated import statements
- Non-idiomatic code patterns
llama-3.1-8b-instant for rapid analysisAI-powered refactoring
What happens
Files identified in step 2 are processed in parallel—up to 100 files simultaneously—using Modal’s distributed container system:- Complete file rewrites (not just snippets)
- Syntax validation before accepting changes
- Confidence scoring (0-100) for each file
- Detailed AI explanations for every change
- Language-specific modernization rules
llama-3.3-70b-versatile for high-quality refactoringEach file includes a confidence score. Files scoring below 80 are flagged for manual review.
Comprehensive changelog generation
What happens
For every refactored file, Dependify generates detailed changelogs explaining what changed, why it changed, and the impact:- Summary statistics (files updated, lines changed)
- File-by-file breakdown with:
- Key modernizations applied
- AI reasoning for each change
- Confidence score per file
- Lines added/removed
- Review checklist for maintainers
- Categorized changes (deprecations, API updates, best practices)
Automated branch creation and push
What happens
Dependify creates a new branch with a unique identifier, commits all changes, and pushes to GitHub:- Unique branch names prevent conflicts (
dependify-a3f9d2c8) - Authenticated push URLs for private repos
- Automatic handling of fork vs. owned repo scenarios
- Real-time status updates via Supabase
Pull request creation
What happens
Finally, Dependify submits a pull request with the comprehensive changelog:- Professional title with emoji
- Complete changelog with file-by-file breakdown
- Review checklist for maintainers
- Confidence scores for quality assessment
- Links back to Dependify
- Clear instructions for fork cleanup (if applicable)
For external repos, the PR clearly indicates it’s from a temporary fork that can be deleted after merging
Quality assurance features
Syntax validation
Every refactored file is validated for syntax correctness before being accepted:Confidence scoring
Each file receives a confidence score (0-100) based on:- Syntax validity: Does the code parse correctly?
- Semantic preservation: Are the semantics maintained?
- Pattern accuracy: Are modernizations applied correctly?
- Code quality: Is the refactored code cleaner?
| Score | Badge | Recommendation |
|---|---|---|
| 80-100 | 🟢 HIGH CONFIDENCE | Safe to merge after quick review |
| 60-79 | 🟡 MEDIUM CONFIDENCE | Review changes carefully |
| 0-59 | 🔴 NEEDS REVIEW | Requires thorough testing |
Real-time progress tracking
Throughout the entire process, Supabase provides live updates:- Files being analyzed
- Refactoring progress
- Validation results
- PR creation status
Performance characteristics
Parallelization
- Analysis: All files scanned simultaneously in isolated containers
- Refactoring: Up to 100 files processed in parallel
- Warm pools: 3 containers kept warm for instant response
Typical processing times
| Repository size | Files | Processing time |
|---|---|---|
| Small (< 10 files) | 1-10 | 30-60 seconds |
| Medium (10-50 files) | 10-50 | 1-3 minutes |
| Large (50-100 files) | 50-100 | 3-7 minutes |
| Enterprise (100+ files) | 100+ | 7-15 minutes |
Processing time scales linearly with parallel containers. Larger repos may be faster per-file due to warm pool optimization.
Security and privacy
Data handling
- Repository data processed in isolated Modal containers
- No code stored permanently on Dependify servers
- Temporary staging directories cleaned up after PR creation
- GitHub tokens stored securely in Modal secrets
Authentication
- GitHub OAuth with 7-day session expiration
- JWT tokens for API authentication
- Scoped GitHub tokens (only
repoaccess required) - Automatic token refresh handling
Next steps
Try it now
Start modernizing your code
Quickstart
Detailed setup guide
API reference
Integrate into your pipeline
GitHub integration
Learn about fork management