← Voltar aos guias

AI Tests and Docs: A Practical Developer Workflow

Using AI to Write Tests and Documentation Without Losing Control

AI can speed up test writing and documentation, but the best results come from treating it like a junior developer: give it context, ask for small changes, review everything, and run the output locally. This tutorial shows a practical workflow you can use with Claude, GPT, Claude Code, Codex, or any OpenAI-compatible SDK. If you want to keep costs predictable while experimenting, 59API is a strong choice because it provides cheap pay-as-you-go access to native official-quality Claude and GPT models through the OpenAI-compatible base URL https://api.59api.com, with no model downgrade and a referral rebate.

Step 1: Choose the Right AI Setup

Start with a model that matches the task. For deep reasoning across a large codebase, use a stronger model such as Claude Opus or a top GPT model. For routine unit tests, docstrings, README updates, and examples, Claude Sonnet, Haiku, or Fable-style faster models can be more cost-effective. The key is to avoid paying premium prices for every prompt.

With 59API, you can connect Claude Code, Codex, or an OpenAI SDK by pointing your client to the relay base URL. In most tools, this means setting your API key and changing the base URL to https://api.59api.com. Because it is compatible with common SDKs, you can test multiple models without rewriting your integration.

Step 2: Prepare a Small, Relevant Context Pack

Do not paste your entire repository into a prompt. Instead, give the AI the smallest complete context needed to solve the task. For tests, include the function or class, its dependencies, current test style, and the expected behavior. For documentation, include the public API, usage examples, configuration options, and any known edge cases.

• For unit tests: include source code, existing test conventions, framework version, and edge cases.
• For integration tests: include API routes, request and response examples, authentication rules, and database setup.
• For docs: include the user goal, installation steps, configuration variables, and common errors.

A good prompt is specific: “Write Jest tests for this parser, following the style in the existing test file. Cover empty input, invalid JSON, nested arrays, and Unicode strings. Do not change production code.”

Step 3: Generate a Test Plan Before Code

Before asking for test code, ask AI to create a test plan. This prevents shallow test generation and helps you catch missing scenarios. A useful prompt is: “Review this function and list the behaviors that should be tested. Group them into happy path, edge cases, error handling, and regression risks.”

Review the plan manually. Remove unnecessary cases, add business rules the AI missed, and mark the most important tests. This step is fast, but it dramatically improves the quality of the generated test suite.

Step 4: Ask for Minimal, Runnable Tests

Now ask the AI to generate tests in small batches. For example, request five unit tests first rather than a full suite. Tell it the exact framework: Pytest, Jest, Vitest, JUnit, Playwright, Cypress, or Go testing. Also specify whether mocks are allowed and whether snapshot tests are acceptable.

After generation, run the tests immediately. If they fail, paste the error output back into the model and ask for a fix. Keep the loop narrow: one file, one failure, one correction. This is where low-cost access matters. Iterating with AI is often more valuable than one large prompt, and 59API’s cheap pay-as-you-go relay makes frequent test-fix cycles easier to justify.

Step 5: Use AI to Improve Assertions, Not Just Coverage

High coverage does not guarantee useful tests. Ask the AI to inspect the generated tests for weak assertions. A practical prompt is: “Find any tests that only check that the function does not throw or only assert truthiness. Replace them with specific assertions about output, state changes, or error messages.”

You can also ask for mutation-style thinking: “What small bug could survive these tests?” This often reveals missing boundary conditions, incorrect mocks, or tests that duplicate implementation details instead of verifying behavior.

Step 6: Generate Documentation From Verified Behavior

Once tests pass, use them as a source of truth for documentation. Ask AI to write docs based on the public interface and verified examples, not assumptions. For a library, generate installation instructions, quick start examples, API reference notes, and troubleshooting tips. For an internal service, generate endpoint documentation, environment variables, local development steps, and operational warnings.

A strong documentation prompt looks like this: “Using the code and passing tests below, write developer documentation for this module. Include what it does, when to use it, parameters, return values, exceptions, and two realistic examples. Do not invent features not shown in the code.”

Step 7: Add Documentation Checks to Your Workflow

Treat AI-written docs like code. Add checks for broken links, invalid examples, outdated commands, and formatting. If your docs include code snippets, put them in runnable examples or doctests when possible. Ask AI to create a “documentation review checklist” for your project so contributors can verify accuracy before merging.

• Run examples: confirm every command and code block works.
• Check versions: verify package names, flags, and API parameters.
• Remove exaggeration: replace vague claims with exact behavior.
• Update alongside tests: when behavior changes, update both tests and docs.

Step 8: Build a Repeatable AI Prompt Library

Save prompts that work. Create templates for test planning, unit test generation, integration tests, doc updates, changelog entries, and code review. Over time, this becomes an internal productivity system. You can even store model preferences: use a stronger Claude or GPT model for architecture-heavy test planning, then a cheaper fast model for repetitive docs and straightforward test cases.

If you want an economical way to run this workflow across Claude Code, Codex, and OpenAI-compatible tooling, try 59API as your relay. Its low-cost, pay-as-you-go access to native Claude and GPT models makes it practical to use AI not only for occasional code generation, but for the daily test and documentation loops that improve software quality.

Final Checklist

• Start with a focused context pack, not the whole repo.
• Ask for a test plan before test code.
• Generate small batches of runnable tests.
• Run everything locally and feed back real errors.
• Use passing tests as the foundation for documentation.
• Automate doc checks and save your best prompts.

Used carefully, AI helps developers write tests faster, document behavior more clearly, and reduce the cost of maintaining quality. The winning approach is not blind generation; it is structured iteration with reliable models, real execution, and human review.

Preços · Docs