Don't want to set this up manually? Paste a link to this page into a Devin session and ask it to set everything up for you. Your e-commerce monorepo has 30+ modules but only a handful have meaningful test coverage. You want to go from 44% overall coverage to 80% — starting with the 8 worst offenders. Before launching parallel sessions, you need a [playbook](/product-guides/creating-playbooks) that ensures all 8 sessions write tests the same way. Ask Devin to create the playbook for you — just describe your testing conventions in any session: ```txt Create a test-writing playbook theme={null} Create a playbook for writing unit tests in our monorepo. It should enforce: 1. Use Vitest with TypeScript. Import from `vitest`. 2. Follow the AAA pattern (Arrange, Act, Assert). 3. Mock external dependencies — never call real APIs, databases, or third-party services. 4. Use test helpers from `src/test/helpers.ts` (e.g., `createMockUser()`, `setupTestDB()`). 5. Place test files at `{module}/__tests__/{filename}.test.ts`. 6. Cover success paths, error paths, and edge cases for every exported function. 7. Run `npm test -- --coverage --reporter=json` and verify the module exceeds 80% line coverage. 8. Open a PR with the new tests. Include the before/after coverage numbers in the PR description. ``` This playbook becomes the shared instruction set for every parallel session. You can also add [Knowledge](/product-guides/knowledge) entries about your test utilities, mocking patterns, or any project-specific quirks (e.g., "always call `resetMocks()` in `afterEach`"). At the end of your workday, open a new Devin session from the [Devin home page](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) and describe the batch task. 1. Select your test-writing playbook from the dropdown 2. Describe the task in the prompt: ```txt Overnight test coverage batch — 8 modules theme={null} Run `npm run test:coverage` against our repo. Identify the 8 modules with the lowest line coverage (skip anything under src/generated/). For each module, start a parallel Devin session using the selected playbook. Each session should: - Read the module's source code and any existing tests - Write new unit tests to bring line coverage above 80% - Run the full test suite to confirm nothing breaks - Open a PR with the new test files and a before/after coverage summary ``` 3. Review the proposed sessions — Devin lists each module with its current coverage and confirms which sessions it will create: ``` Proposed sessions (8 modules, all below 50% coverage): 1. src/services/PaymentService — 31% coverage 2. src/services/UserService — 38% coverage 3. src/api/routes/billing — 42% coverage 4. src/middleware/auth — 44% coverage 5. src/services/NotificationSvc — 47% coverage 6. src/components/Checkout — 49% coverage 7. src/utils/validation — 51% coverage 8. src/services/SearchService — 53% coverage Start 8 parallel sessions? (y/n) ``` 4. Approve the batch and close your laptop. All 8 sessions launch simultaneously on separate Devin machines, each following your playbook independently. By morning, each session has finished and opened its own PR. You'll see 8 PRs in your repository, each containing new test files and a coverage summary: ``` Module | Before | After | PR | Status -----------------------------|--------|--------|--------|-------- src/services/PaymentService | 31% | 87% | #412 | Ready src/services/UserService | 38% | 84% | #413 | Ready src/api/routes/billing | 42% | 91% | #414 | Ready src/middleware/auth | 44% | 82% | #415 | Ready src/services/NotificationSvc | 47% | 85% | #416 | Ready src/components/Checkout | 49% | 83% | #417 | Ready src/utils/validation | 51% | 93% | #418 | Ready src/services/SearchService | 53% | 86% | #419 | Ready Overall coverage: 44% -> 68% (+24 pts across targeted modules) ``` Merge the PRs in any order — since each session only adds new test files to its own module, conflicts are rare. If two sessions touched a shared test helper, resolve the conflict manually or ask Devin to fix it. One overnight batch won't hit your 80% target across the entire codebase. The next evening, run a follow-up for the next tier of modules: ```txt Second overnight coverage pass theme={null} We're at 68% overall and need 80%. Run the coverage report again, find the next 6 lowest-coverage modules (skip anything already above 80%), and start another batch using the same test-writing playbook. ``` You can also shift from unit tests to integration tests for critical user flows: ```txt Batch integration tests for critical flows theme={null} Identify our 5 most critical user flows (signup, login, checkout, password reset, account deletion). Start a parallel session for each to write end-to-end integration tests using Playwright. Each session should test the happy path plus 2-3 error scenarios. ``` Two nights of parallel sessions can take a codebase from under 50% coverage to over 80% — work that would take an engineer weeks of dedicated effort.

{title}