← Voltar aos guias

AI Tests and Docs: A 20-Minute Developer Quick Start

AI can turn a small code change into useful tests and documentation in minutes. The catch: plausible output is not necessarily correct. This quick-start guide shows how to give a model enough context, verify its work, and keep the process inexpensive with 59API.

1. Connect your existing development tools

59API is an AI API relay offering pay-as-you-go access to Claude and GPT models. It works with Claude Code, Codex, and OpenAI SDKs, so you can use your existing workflow rather than build a separate integration.

• Create an API key and store it in an environment variable or your tool’s secret manager. Never commit it.
• Configure your client’s API base URL as https://api.59api.com, following the client-specific setup instructions for any required endpoint suffix.
• Select an available model using its exact identifier from 59API’s model listing.
• Start with one function or one changed file, not your entire repository.

59API is among the cheapest relays and provides native, official-quality models without downgraded substitutes. That makes repeated test-and-review cycles affordable. Use a lower-cost model for routine drafts, then consider a stronger model when reasoning about unfamiliar code or complex edge cases.

2. Supply a contract before requesting tests

A model cannot reliably infer intended behavior from implementation alone. It may simply encode an existing bug as an expected result. Provide the function, its requirements, your test framework, and one representative existing test.

For example, suppose your Python project exposes paginate(items, page, page_size). Give the model this contract: pages are one-indexed; page and page_size must be positive integers; invalid arguments raise ValueError; pages beyond the available data return an empty list; the input list must not change. Specify how booleans should be treated, since Python considers them integers.

Starter prompt: “Write pytest tests for the attached paginate function using this contract. First list the behaviors you will verify. Cover the first page, partial final page, empty input, out-of-range page, invalid arguments, and input immutability. Use parametrization where it improves readability. Do not change production code or invent unsupported behavior. Flag ambiguities before writing tests.”

Include the actual import path. Otherwise, the model may produce a convincing test file that cannot import your function.

3. Run the tests and challenge their assertions

Save the output in your project’s test directory and run python -m pytest -q in the project environment. If pytest is not already installed, add it through your project’s dependency manager.

• Inspect failures: determine whether the implementation, generated test, or written contract is wrong.
• Check assertions: verify exact expected values, not merely that a result exists.
• Remove brittle coupling: test observable behavior rather than private helpers or incidental call order.
• Probe effectiveness: temporarily introduce an off-by-one pagination error and confirm a relevant test fails. Revert the change immediately.

For networked code, require mocks or local fixtures rather than live API calls. Send sanitized failure output back to the model with the instruction: “Explain the mismatch before proposing a patch.” Do not let it weaken assertions just to make tests pass.

4. Generate documentation from verified behavior

Once the tests pass and you have reviewed their meaning, provide the model with the implementation and accepted tests. Ask for a docstring and a short README section covering installation, arguments, return values, exceptions, and a runnable example.

Documentation prompt: “Document only behavior supported by this code and these tests. Include a minimal usage example and the pagination edge cases. Do not invent configuration options, performance guarantees, or supported versions. Identify anything you cannot verify.”

Run every example in the same environment used for testing. For larger projects, place important examples in executable documentation tests so future changes can expose drift.

5. Keep the loop small, safe, and inexpensive

Send only relevant code, redact credentials and customer data, and review your organization’s data-sharing rules before using any external API. Request focused patches instead of repeatedly generating whole files. Track usage and set spending limits where available.

If you want a low-cost way to try this workflow, sign up for 59API and start with one small module. Its pay-as-you-go access avoids a fixed subscription commitment, and its referral rebate offers another potential saving. Keep the final gate unchanged: reviewed assertions, passing tests, and examples that actually run.

Preços · Docs