# Add a User Profile Page to a Filament Panel

Yes. An agent turns on Filament's profile page in each panel, keeps it inside the panel layout, covers name, email and password changes with Pest tests, in a PR.

[Run this on Rush](https://cloud.getrush.ai/run/add-user-profile-page/filament/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent reads the panels before it adds a page. In an app like filamentphp/demo, `composer.json` runs `filament/filament` 5 on Laravel 12 with Pest 3 and Pint, and `CLAUDE.md` pins the same versions for anyone editing it. `app/Providers/Filament/AdminPanelProvider.php` builds the `admin` panel with a custom `Login` page from `app/Filament/Pages/Auth/Login.php`, which pre-fills the demo credentials, `databaseNotifications()`, global search key bindings, `spa()` and a Vite theme; `app/Providers/Filament/AppPanelProvider.php` builds the `app` panel at `/app` with `registration()`, `passwordReset()`, `emailVerification()` and `tenant(Team::class)`. Neither provider calls `profile()`, so a signed-in user has nowhere to change their name, email or password. The `users` table from `2021_12_13_000001_create_users_table.php` holds `name`, `email`, `email_verified_at`, `password` and `remember_token`; `app/Models/User.php` implements `FilamentUser`, `HasTenants` and `MustVerifyEmail`. `tests/Pest.php` binds every test under `tests/Filament` to `RefreshDatabase` and signs in a factory user, and `.github/workflows/tests.yml` runs `composer test:pest` on PHP 8.4 with SQLite.

It uses the page Filament ships rather than writing one. `->profile(isSimple: false)` goes on both panels so the page renders inside the panel's navigation and theme instead of the bare auth layout, and the user menu gains the profile link Filament adds for it. The admin panel keeps the demo `Login` page; the app panel's tenancy means the profile route is tenant-scoped like its other pages, which the agent checks by reading the registered route list with `php artisan route:list`. Because `User` implements `MustVerifyEmail` and the app panel enables email verification, the agent reads what the built-in page does when the email changes and writes that behaviour down in the pull request rather than assuming it.

Where the default does not fit, it subclasses. If the review of the base page shows a field the demo should not expose, or the demo wants the profile under its own navigation group, the agent adds `app/Filament/Pages/Auth/EditProfile.php` extending Filament's `EditProfile`, overrides only the form schema or the navigation properties, and registers that class in `->profile(...)`; otherwise it leaves the base class in place and says so. No new column is added: the page edits what the `users` table already has.

Then it tests like the rest of the suite. New Pest files under `tests/Filament/Pages/Auth/` use `Livewire::test` on the profile page class, fill the form with a new name and email, call `save`, assert no form errors and `assertDatabaseHas` on `users`; a second test sets a new password with its confirmation and asserts the stored hash verifies against it; a third asserts a mismatched confirmation fails validation. It runs `composer test:pest` and `vendor/bin/pint --test`, as the workflow and `pint.json` expect, before opening the pull request.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Add a user profile page to both Filament panels in this app. Read composer.json, CLAUDE.md, app/Providers/Filament/AdminPanelProvider.php, app/Providers/Filament/AppPanelProvider.php, app/Filament/Pages/Auth/Login.php, app/Models/User.php, database/migrations/2021_12_13_000001_create_users_table.php, database/factories/UserFactory.php, tests/Pest.php, one existing test under tests/Filament/Resources and .github/workflows/tests.yml first. Call profile with isSimple false on each panel so the page renders inside the panel layout. Check what the built-in page does when the email changes given MustVerifyEmail and the app panel's emailVerification, and describe it in the pull request. Only subclass EditProfile if a field or the navigation needs to change, and keep the users table as it is. Add Pest tests with Livewire::test for changing name and email, changing the password with confirmation, and a mismatched confirmation. Run composer test:pest and vendor/bin/pint --test, then open a pull request that names the route in each panel and the tests added.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

What comes back is a pull request that edits `app/Providers/Filament/AdminPanelProvider.php` and `app/Providers/Filament/AppPanelProvider.php`, adds `app/Filament/Pages/Auth/EditProfile.php` only if the base page needed a change, and adds Pest tests under `tests/Filament/Pages/Auth/`. The description names the profile route in each panel, lists the fields the page edits, states what happens on an email change under email verification, and says that no migration was added.

The run's record keeps the `composer test:pest` output with each test named and the Pint result, so a reviewer sees the three profile tests pass beside the existing resource tests on the same SQLite setup the workflow uses.

Before merging, a reviewer signs in to the admin panel with the pre-filled demo credentials, opens the profile from the user menu, changes the name and sees it in the header, then does the same in the app panel inside a team to confirm the tenant-scoped route works.

## Run it on every Linear issue labelled account-settings

In the console, add an automation to the Project with this prompt and a `linear` trigger on `linear.issue.labeled`, filtered to the `account-settings` label and the admin-panel team. When someone labels an issue such as "users cannot change their password after the first login", the trigger puts the issue after the prompt and the run scopes itself to the panel and the field the issue names. Only label changes made by a person in your Rush org fire the trigger, and the automation starts at most `max_runs_per_hour` runs in an hour.

From your own server, the same body goes to `POST /o/{org}/sessions` with the repository in `resources` and the issue URL beside it, read through your Linear connection, and a `request_id` that is a UUID v5 of the issue id, so a retried call returns the run already started rather than opening a second pull request.

## Why run it on Rush?

The page itself is one method call; the work is around it: a tenant-scoped panel where the route must resolve inside a team, a `MustVerifyEmail` model where an email change has consequences, a custom login page that must keep working, and a test suite with its own sign-in convention. The agent reads the route list and the base page in its own sandbox and runs the suite the way CI does, rather than trusting that one line did the right thing in both panels.

The commands and their output stay with the run, so the pull request can point at the Pest run that changed a password and verified the hash, and a reviewer only has to click through the two panels once.

## Frequently asked questions

### Do I need a package for this?

No. Filament ships an `EditProfile` page and a `profile()` panel method; the agent turns it on in each panel and adds nothing to `composer.json`.

### What does isSimple false change?

By default the profile renders on the plain auth layout used by login. With `isSimple: false` it renders inside the panel with its navigation, theme and user menu, which is what the demo's other pages use.

### What happens when a user changes their email?

`User` implements `MustVerifyEmail` and the app panel enables email verification, so the agent reads how the built-in page treats a changed address and states it in the pull request, with a test that records the stored value. It does not guess at the behaviour or add its own verification flow.

### Does the page work inside a team in the app panel?

The app panel uses `tenant(Team::class)`, so its pages are tenant-scoped; the agent reads the registered routes to confirm the profile route is too and names it in the description. A reviewer opens it from within a team before merging.

## More Filament jobs

- [Write an Architecture Overview of a Filament Admin Panel](https://getrush.ai/run/architecture-overview/filament/)
- [Dockerize a Filament App](https://getrush.ai/run/dockerize-app/filament/)
- [Upgrade Filament and Composer Dependencies](https://getrush.ai/run/upgrade-composer-dependencies/filament/)

## More jobs like this: Turn a Linear label into a PR

- [Add User Registration to a Symfony App from a Linear Issue](https://getrush.ai/run/add-user-registration/symfony/)
- [Add a values.schema.json to a Helm Chart](https://getrush.ai/run/add-values-schema/helm/)
- [Add Variable Validation to a Terraform Module from a Linear Issue](https://getrush.ai/run/add-variable-validation/terraform/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
