Short answer
You can use GitHub Copilot for developer-driven test generation (in-editor, fast feedback) and an automated API-based generator in CI (OpenAI/ChatGPT or a local model) to create tests at scale. Copilot is excellent for iterating tests while coding, but it’s not a headless CI service—so combine both for safety, review, and deterministic CI runs.

Recommendation
- Use Copilot in VS Code for interactive test authoring and for seeding test templates and edge cases.
- In CI, run a deterministic generator script (calls OpenAI / internal model) that creates candidate tests, then require: lint, run tests, flakiness detection, and a human review PR before merging.

Why this hybrid approach
- Copilot: best for developer intent, quick per-file tests and context-aware suggestions.
- CI automation: required for reproducible, auditable generation; Copilot doesn’t currently run headless in CI.

Decision criteria
- Budget: calling OpenAI in CI costs money per file; smaller teams may prefer developer-driven Copilot and gated PRs. Large codebases benefit from automated generation but need budget for API calls and build time.
- Skill level: junior teams should prefer Copilot + reviewer checks; engineering teams can build CI generators and flakiness detectors.
- Workflow stage: early projects can accept manual Copilot tests; mature projects need deterministic CI generation and strict review.
- Team size/output quality: bigger teams must enforce stricter flakiness rules and coverage thresholds.

Practical prompts
1) Copilot (in-editor, small snippet):
"Generate Jest unit tests for the code below. Focus on pure functions, cover normal, boundary, and error cases. Use jest mocks for any module or network calls. Do not use timers or network. Put tests in __tests__/file.test.js and aim for readable assertions."

2) CI generator (OpenAI-style prompt to send the file content):
"You are an expert JavaScript tester. Given this file, produce Jest unit tests that:
- Avoid real network or filesystem access (use jest.mock).
- Use deterministic values and fixed seeds where randomness exists.
- Include 3–5 clear tests (happy path, boundary, error, edge case).
- Do not include snapshots unless output is purely structural and stable.
- Return only the test file contents and the recommended path."

Test template (Jest + Node monorepo friendly)
// __tests__/example.test.js
const subject = require('../example');
jest.mock('../http-client'); // or sinon stub

describe('example', () => {
beforeEach(() => jest.clearAllMocks());

test('happy path returns expected value', () => {
const res = subject(2, 3);
expect(res).toBe(5);
});

test('throws on bad input', () => {
expect(() => subject(null)).toThrow(/invalid/);
});
});

CI hooks (GitHub Actions example sketch)
name: Generate tests
on: [pull_request, workflow_dispatch]
jobs:
generate-and-run:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with: node-version: '18'
- run: npm ci
- name: Run test-generator
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
run: node scripts/generate-tests.js --packages changed
- name: Lint and run tests
run: |
npm run lint && npm test -- --runInBand
- name: Flakiness check (run twice)
run: |
npm test -- --runInBand || exit 1
npm test -- --runInBand || (echo "Flaky tests detected" && exit 1)
- name: Fail if generated tests change files
run: |
git diff --exit-code || (echo "Generated tests changed files; open PR for review" && exit 1)

Practical checklist before enabling auto-generation
- Define what tests are allowed (unit only, no e2e).
- Choose generator: Copilot (manual) vs API (automated). Budget the API calls.
- Enforce mocks for network/IO; add eslint rules to ban real network in tests.
- Run tests twice in CI to detect flakiness; fail if results differ.
- Require PR for generated tests (auto-PR ok but must have human approval before merge).
- Add coverage gates per-package, not global (monorepo scale).

Avoid if
- You have heavy integration tests or DB-dependent logic—AI will often make brittle tests.
- Your team lacks reviewers—auto-generated tests should never be merged without human review.

Best for
- Increasing coverage for pure utility modules and small services.

Tools
- Use GitHub Copilot for in-editor assistance; for automated CI generation, run an API-based approach (ChatGPT/OpenAI or a local model). For the developer workflow, see GitHub Copilot: Read more about GitHub Copilot

If you want, I can: provide a ready generate-tests.js that calls OpenAI and writes tests, plus a concrete GitHub Actions YAML and a sample eslint rule to ban network calls from tests.