Your codebase is data, not strings
Import your existing Laravel project into Stellify and query it like a database. Find fat controllers, missing relationships, and security gaps in seconds. Refactor with AI that edits specific methods by UUID—without touching surrounding code.
Every AI coding tool works on text files. Stellify stores code as structured JSON with relationships. That's not a technical detail—it's the difference between grep and SQL.
The advantage every text-based tool lacks
Every file, method, statement, and clause in Stellify has a UUID and structured relationships. This means you can ask questions about your codebase that are impossible in a text editor without manually auditing every file.
More importantly, AI can make changes that would be dangerous with text manipulation. Rename a model across 50 files? Text-based AI rewrites each file and hopes line numbers didn't shift. Stellify updates references by UUID—the operation is structural, not textual.
Query your codebase like a senior developer would
These are the questions an experienced developer asks during code review or when onboarding to a new project. Stellify answers them programmatically.
"Which controllers have methods longer than 50 statements?"
Instantly identifies fat controllers that need refactoring. In VS Code you'd be opening every file and eyeballing it.
"Which models have no relationships defined?"
Finds models that are probably incomplete or being used as dumb data containers when they should have proper Eloquent relationships.
"Which controller methods don't use form requests?"
A code quality audit that would take hours becomes instant. Find every store/update method that validates inline instead of using dedicated form request classes.
"Which routes have no middleware?"
Security audit in seconds. Find unprotected routes that should have auth, throttling, or other middleware applied.
"Show me every method that calls DB:: directly"
Finds raw queries that bypass your model layer. These often indicate missing Eloquent relationships or scopes that should be added.
"Which methods reference a model that no longer exists?"
Dead reference detection. Find orphaned code that references deleted models, saving you from runtime errors in production.
"Which services are only used by one controller?"
Finds candidates for inlining or consolidation. Over-abstraction creates cognitive overhead—sometimes the "service" should just be a method.
"Which migration fields aren't in the model's $fillable?"
Compare your migrations against your models. Find fields you're storing but can't mass-assign, which often indicates incomplete model definitions.
Surgical refactoring, not file regeneration
This is where AI working on structured data beats AI working on text files. Every operation targets specific statements by UUID—surrounding code is untouched by definition.
Extract method
Take lines 45-80 of a controller method and move them into a new private method or service class. AI knows exactly which statements to move because they're individually addressable. It creates the new method, moves the statements, adds the call in the original method, and handles variable dependencies.
In a text-based tool: AI rewrites the entire file and hopes the line numbers didn't shift. You review 200 lines of diff to verify 20 lines actually changed.
Move to service
Take business logic out of a controller and into a dedicated service class. AI creates the service file, creates the method, moves the relevant statements, adds the constructor injection in the controller, and updates the method to call the service.
Multiple files, precise changes: Each modification is targeted. The controller's other methods aren't regenerated—only the injection and the calling code change.
Add validation
AI examines a controller's store/update method, analyses the statements to understand what data is being used, and generates a form request class with the right rules. It then updates the controller method signature to type-hint the form request instead of using Request.
Structural understanding: AI doesn't guess what fields you're validating—it reads the statements that use request data and generates rules that match actual usage.
Standardise return types
Find every controller method that returns inconsistent response formats—some return views, some return JSON, some return redirects with no pattern. AI can standardise them to follow your conventions.
Pattern enforcement: Once you've defined the pattern, AI applies it across every method that needs updating. Consistency becomes automatic.
Add missing relationships
AI compares your migration files (which define foreign keys) against your model files (which define Eloquent relationships). If a migration has a user_id foreign key but the model doesn't have a belongsTo relationship, AI adds it.
Cross-file analysis: The relationship between migrations and models is structural. AI doesn't need to parse text—it queries the data.
Cross-file changes with confidence
Because Stellify stores everything as structured data with references, AI can make changes that span multiple files without the risks of text-based manipulation.
Rename a model
Rename Post to Article and have it update the model file, every controller that references it, every route, every migration, every factory, every seeder, and every relationship on other models.
In a text editor this is find-and-replace and prayer. In Stellify the references are structural.
Change a method signature
Add a parameter to a service method and have every caller updated automatically, because Stellify knows which statements in which methods call this method.
No grep, no manual verification, no missed call sites discovered in production.
Delete a route
Remove a route and identify the controller method that's now orphaned, the middleware that might no longer be needed, the form request that's no longer used.
Cleanup becomes comprehensive instead of best-effort.
The moment that builds trust
Show a refactor. Then show the diff.
Point out that only the targeted code changed—everything else is byte-for-byte identical.
That's the moment an experienced developer thinks "ok, I trust this."
Cursor reads your file as a string and makes its best guess. If you say "extract this into a service", Cursor rewrites the controller file and creates a new service file. But it might miss updating the route file, or forget to add the service to a service provider, or accidentally change code outside the target area because it regenerated the whole file.
Stellify's AI operates on identified, addressable units. It moves specific statements by UUID from one method to another. It doesn't regenerate surrounding code because it doesn't need to—it's editing cells in a spreadsheet, not rewriting a paragraph in a document.
Maintenance and ongoing improvement
Beyond one-off refactors, there's a maintenance story. These aren't occasional tools—they're part of your regular workflow.
Quality analysis
Check for fat controllers, missing validation, raw DB queries, unused methods, inconsistent naming, and missing return types. Get a prioritised list of improvements, not a wall of warnings.
Performance analysis
Identify N+1 query risks (methods that load a model then access a relationship in a loop without eager loading), oversized queries, and missing indexes based on common query patterns.
Generate missing tests
AI examines controller methods, understands inputs and outputs structurally, and generates feature tests covering happy paths and validation failures. It knows your form request rules, so tests cover actual validation logic.
Consistency checks
When someone adds a new model, check whether it follows established patterns: does it have a factory? A seeder? Relationships matching the migration? A policy if other models have policies?
Frequently asked questions
Common questions about importing and working with existing Laravel projects.
How do I import my existing Laravel project into Stellify?
You can import your project using the GitHub sync feature. Connect your repository, and Stellify will parse your controllers, models, and other PHP files into its structured format. The import is non-destructive—your original codebase remains unchanged.
Will Stellify work with my custom packages and non-standard patterns?
Stellify handles standard Laravel patterns out of the box. For custom packages or unconventional patterns, you can use the query tools to understand your codebase first, then selectively import the parts that benefit most from structured refactoring. You don't have to import everything.
Can I export my code back to standard Laravel files?
Yes. Stellify exports to standard Laravel PHP files and Vue components. The exported code is identical to what you'd write by hand—no lock-in, no proprietary syntax. You can work in Stellify for refactoring, then export and deploy normally.
How does the AI refactoring compare to doing it manually?
Manual refactoring requires you to track every reference across files, update tests, and hope you didn't miss anything. Stellify's AI operates on structured data—it knows every reference by UUID. When you rename a model, every controller, relationship, migration, and factory updates automatically. The diff shows only targeted changes.
What about my existing tests?
You can import existing tests and continue running them. Stellify can also generate missing tests by analysing your controller methods structurally—it knows your validation rules, return types, and dependencies, so it generates tests that cover actual behaviour, not guessed scenarios.
Is this only useful for legacy code cleanup?
No. The query and refactoring tools are valuable for any codebase. Even well-maintained projects accumulate inconsistencies over time—missing relationships, inconsistent return types, validation gaps. Stellify makes finding and fixing these systematic rather than ad-hoc.
See your codebase as data
Import your existing Laravel project and run your first query. Find patterns, inconsistencies, and opportunities that were invisible before.
No credit card required