Short answer / recommendation
Use GitHub Copilot in VS Code to generate test skeletons during active development: enable inline suggestions, prompt with a clear “what, framework, and constraints” pattern, then iterate by asking for edge cases and mocks. For bulk or policy-driven test generation (large files, strict style), use ChatGPT to refine prompts or generate multiple variants offline.

Why this works
Copilot is fastest when it completes in-context code (small function + prompt). It struggles less with concrete expectations (Jest/pytest, names, input ranges). ChatGPT helps when you need consistent multi-file scaffolding or human-reviewed templates.

Decision criteria (which tool / pattern to use)
- Small-to-medium functions, day-to-day dev: Copilot in VS Code (fast, local).
- Bulk/generator across repo, or need consistent wording/PR text: ChatGPT (batch runs).
- Budget/scale: Copilot requires a subscription for full features; ChatGPT may be better for ad-hoc large runs if you have API credits.

Concrete prompt patterns (copy-paste and adapt)
TypeScript (Jest + ts-jest, typed inputs)
- Minimal skeleton: "Create a Jest unit test skeleton for this TypeScript function. Include imports and 3 tests (happy path, invalid input, edge case). Use typed inputs and assert error cases with toThrow()."
- Full test file: "Given the following function, generate a full Jest test file with mocks for external modules, fixtures, and parameterized tests for boundary values. Use describe/it blocks and clear test names."
Python (pytest)
- Minimal skeleton: "Generate pytest unit tests for this Python function. Include a fixture for setup, at least 3 parametrized cases, and an error case with pytest.raises()."
- With monkeypatch: "Create pytest tests using monkeypatch to replace the external API call, with assertions on calls and return values. Use type hints in tests."

How to prompt in-editor (practical flow)
1. Place cursor above or next to the function. Add a one-line prompt comment starting with TODO or a special tag, e.g. // TEST: or # TEST: and then paste one of the prompts above.
2. Accept Copilot inline suggestions or press Ctrl+Enter (or the Copilot accept key) to see alternatives.
3. If the first output is skeletal, ask inline: "Add edge-case tests for null, empty, and extreme numeric inputs" or "Mock dependency X to return error".

VS Code + Copilot settings to enable (quick checklist)
- Enable Inline Suggestions: Editor: Inline Suggestions (editor.inlineSuggest.enabled = true).
- GitHub Copilot extension: enable inline completions (Settings > Extensions > GitHub Copilot > Inline Suggestions).
- Turn on quick suggestions while editing (Editor: Quick Suggestions).
- Use the Copilot pane for multiple suggestions and accept/insert the one you want.

Practical checklist before committing tests
- Review each AI-generated assertion for correctness and false positives.
- Add type annotations (TS) or typing comments (Py) if missing.
- Ensure mocks restore state (pytest fixtures/afterEach).
- Run coverage and add missing quick tests manually for tricky control flow.

Best-for / Avoid-if
- Best-for: speeding up boilerplate tests, creating parameterized cases, and prototyping coverage.
- Avoid-if: you need domain-specific invariants, security-sensitive asserts, or 100% predictable naming/style across a large team without review.

Tools mentioned
GitHub Copilot (in-editor generation) — CTA: try github-copilot
ChatGPT (optional) for bulk/refinement

If you want, paste a TypeScript or Python function here and I’ll show a ready-to-run test file and the exact prompt to place above it.

Compare GitHub Copilot and Cursor