Shipping Freddy

Freddy works at https://freddy.test. That's not shipped — that's "done on my machine." The last mile is an audit, metadata, docs, and a deploy: the unglamorous checklist work agents happen to be perfect for.

The problem

Between a working app and a shipped one sits everything nobody wants to do: the security pass, the dependency audit, the meta tags, the README, the production .env, the deploy pipeline. None of it is hard. All of it is easy to skip, and everything you skip becomes a production incident with your name on it.

The hard way

Shipping day as a scramble: a half-remembered checklist from the last project, a frantic grep for hardcoded secrets, APP_DEBUG=true discovered in production three days later by a stranger reading your stack traces. The hard way isn't harder work — it's the same work, done under pressure, with pieces missing.

The Elyra way: the final audit

Start with the health check. /doctor runs the full audit — security issues, outdated dependencies, code debt:

/doctor

  Security: 1 issue — mass assignment: Note::$guarded is
  empty; archived_at is user-settable via store().
  Dependencies: 2 outdated (patch-level), 0 vulnerable.
  Debt: NoteController::index() at 61 lines, mixed concerns.

/doctor --heal

  Applied safe fixes: pinned $fillable on Note, bumped 2
  patch-level dependencies, composer test still green.

--heal takes only the safe fixes; the 61-line controller stays your call. Then the last two gates, both familiar by now: one final /review --cross over the whole diff since the last release — the cross-vendor reviewer from Chapter 8 gets the closing word — and /goal composer test green one more time.

SEO and discoverability

Freddy has a landing page and public browse pages, which means Freddy has an SEO problem you haven't thought about. Install @elyracode/seo and let it do the thinking:

> Run an SEO audit on the landing and browse pages, then fix
  what you find.

  Audit: missing meta descriptions (2 pages), no Open Graph
  tags, no structured data, no llms.txt.
  - Added title + description meta per page
  - Added og:title/og:description/og:image
  - Added WebApplication structured data to the landing page
  - Generated llms.txt describing Freddy for AI crawlers

Ten minutes of work you'd have skipped, and Freddy is legible to search engines and language models alike.

Docs and the paper trail

Documentation written from memory drifts; documentation generated from the codebase can't. The agent has read every file — let it write the README (install steps, the SILT stack, the command list) and a short user guide straight from what's actually there:

> Generate README.md: install, stack overview, commands
  (composer test, migrations, queue). Then a short docs/guide.md
  for users: capture, tags, search, archive.

Two more commands close the paper trail. /export writes the current session as a self-contained HTML file — the build log as an artifact, the answer to "why did we do it this way?" six months from now. And /share publishes a session as a secret GitHub gist when a teammate asks the same question today.

Deploying

Freddy doesn't care whether he lands on Forge, Ploi, Docker, or a bare VPS — the checklist is the same, so have the agent write it down and then write the pipeline:

> Write a production checklist and a GitHub Actions deploy
  workflow. Checklist: APP_ENV=production, APP_DEBUG=false,
  APP_KEY set, real APP_URL, built assets, migrations on
  deploy, queue worker restart.

The workflow that lands in .github/workflows/deploy.yml, condensed:

name: deploy
on:
  push:
    tags: ["v*"]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: composer install --no-dev --optimize-autoloader
      - run: npm ci && npm run build
      - run: composer test
      - name: Deploy
        run: |
          rsync -az --delete ./ deploy@server:/srv/freddy
          ssh deploy@server "cd /srv/freddy &&
            php artisan migrate --force &&
            php artisan queue:restart"

Tag a release, and the same suite that gated every feature gates the deploy. Freddy is live.

The fourteen habits

Fourteen chapters, one habit each. Freddy was the excuse; these are the product:

1. Interview me, don't build me.
2. /init — the project carries its own rules.
3. Two providers, matched dials.
4. Pin the contract, read the auto-context.
5. The live schema is the truth.
6. Make the agent look at its own UI.
7. Tests are the definition of done.
8. Cross-vendor review breaks blind spots.
9. Big features in isolated worktrees.
10. Total undo makes experiments cheap.
11. Persist what you teach.
12. The glue work is agent work.
13. Measure the models.
14. Shipping is a checklist, and checklists are agent food.

What you learned

• The last mile is checklist work — and checklists are exactly what agents don't skip.
• /doctor, then /review --cross, then green tests — three gates, in that order, before anything ships.
• Docs generated from the codebase can't drift; /export and /share keep the "why" on record.
• The deploy is just the test suite with a server at the end.