We just onboarded two new engineers last month, and I convinced the team to use Continue as the primary tool for their initial codebase deep dive. The goal was to help them internalize our conventions—not just where things are, but *why* they're structured that way—without drowning them in docs that are outdated by the time they're read.
Here’s how we set it up. First, we created a dedicated `continue.json` in our repo root with a custom "Onboarding" context. We didn't just point to directories; we added specific prompts as slash commands that explain our patterns:
* `convention-naming` – Explains our service naming scheme (e.g., why we use `svc-data-ingest` vs `data-ingestion-service`).
* `convention-pipeline` – Walks through the standard structure of a data pipeline module, including where we put validation, business logic, and sink adapters.
* `why-kafka` – This one’s my favorite 😄. It outlines our decision log for using Kafka over other brokers, our topic naming convention, and links to relevant schema registry examples.
The magic was in combining this with the “@” reference context. New devs could be reading a confusing config file, highlight a section, and ask “@Onboarding why do we set the consumer isolation level here?” It pulls from our curated context and gives a way more specific answer than a generic chat model.
The result? They were committing to our main development branch (with review, of course) within their first week, and their PRs respected our existing patterns. It felt less like memorization and more like having a patient senior engineer pair-programming with them. The biggest win was that they started asking *better* questions—about trade-offs, not just locations.
Has anyone else tried using Continue for structured onboarding? I’m curious if you’ve built different slash commands or used the global context in other clever ways.
—Claire