Practical Goal: Teach an AI Assistant to “Draw”

In the previous conceptual article, we looked at the nature of a “skill”: a work instruction written for a model. This article moves into practice. We will complete a real-world task: have an AI coding assistant read a technical article, extract its core content, automatically call a text-to-image API, and generate a suitable illustration for the article.

Throughout the process, I did not hand-write a single line of code. All code, configuration, and debugging were completed autonomously by the model through multiple rounds of dialogue with me. That is the most valuable part of this exercise: the human defines the goal and acceptance criteria, while the model handles implementation details. This is also the core of the current “AI-assisted development” paradigm—your role shifts from “the person who writes code” to “the person who states requirements and validates results.”

Prerequisites: Three Things to Clarify First

Before starting, you need to understand three basic concepts. Otherwise, configuration will run into obstacles later.

What Is an API Call?

Think of an API as a service window:

1. You hand in an “order” (a structured request).
2. You do not need to care about the processing logic inside the window.
3. When processing is complete, the result is returned to you in an agreed format.

Using a typical image-generation API as an example, a call usually follows this flow:

Your program ──key + request parameters──▶ Server endpoint
                                            │
                                            ├── verify identity
                                            ├── parse parameters (prompt, size, count, etc.)
                                            ├── run model inference to generate images
                                            │
Your program ◀──image URL or data───────────┘

A typical request structure (illustrative) generally contains three parts: endpoint address, authentication information, and business parameters. The pseudocode structure looks like this:

POST /v1/images/generations
Headers: { "Authorization": "Bearer <your key>" }
Body: {
  "model": "<model identifier>",
  "prompt": "a prompt describing the image content",
  "size": "1024x1024"
}

The response usually returns a temporary URL or binary data for the image. The program can then download and save it. Remember one point: the calling pattern is common across the industry. When you switch platforms, only the endpoint address and parameter names change; the overall structure remains the same.

API Keys: Your Identity and Access Credential

Paid services require credentials, and that credential is the API key. It serves two roles at the same time:

• Identity: tells the server which account the request comes from.
• Access credential: proves that you are authorized to use the service and that charges should be billed to that account.

Several hard rules follow:

1. Never commit keys to public code repositories. Before committing code, make sure keys are excluded from version control.
2. Do not expose keys in plain text in chat logs, screenshots, or documents. When a model generates code, the key should be read from an environment variable rather than hard-coded in source code.
3. If you suspect a leak, revoke and reissue the key immediately. Anyone who obtains your key can directly consume your account balance.

The best practice is to maintain a local environment file that is not tracked by version control and read environment variables in code:

# .env file (add to .gitignore)
IMAGE_API_KEY=sk-xxxxxxxx

import os
api_key = os.environ["IMAGE_API_KEY"]

Token-Based Billing: Understand the Cost Model

A token is the smallest unit of text that a model processes, roughly comparable to a “word piece.” A Chinese prompt will be split into a number of tokens, and input and output are billed separately. For image-generation services, billing is often based on the number of images or resolution. However, if the prompt itself goes through a multimodal large-model workflow, token consumption may also occur.

When estimating costs, it is advisable to do a simple calculation first: average cost per image × expected output × redundancy factor (retries and discarded drafts). For example, if one image costs $1 and a content production run may require 3–5 attempts to get a satisfactory result, the illustration cost per article is $3–$5. With this number in mind, you can rationally control prompt conciseness and the number of retries.

How to Choose an Image-Generation Model: Three General Criteria

Choosing an image-generation service is not about which name is most famous. Use three dimensions for an objective evaluation:

1. Price and billing model: compare cost per image and note whether there is a minimum top-up threshold.
2. Free quota: many platforms offer a limited free quota to new users, which is very useful for validating the workflow before deciding whether to pay for scale.
3. Generation quality and scenario fit: illustrations for technical articles need “accurate meaning and consistent style,” not maximum artistic flair. It is recommended to run the same set of prompts on multiple candidate models and compare how well they follow composition instructions, text content, and style descriptions.

It is worth emphasizing that the methodology in this article is platform-agnostic. Any open platform that provides text-to-image capabilities—whether a large cloud provider or a vertical AI platform—follows the same integration path: register and obtain a key → read the API documentation → confirm the request parameter structure → write a calling script. If you switch to another provider, you only need to read that provider’s documentation again; the instruction framework remains unchanged.

Hands-On Workflow: From Zero to Automatic Image Generation

Step 1: Define the Skill in Natural Language

I opened the coding assistant and described the requirement in one paragraph: “When I need an illustration for an article, please read the article content, extract the theme, call the image-generation API to generate an illustration that matches the content, and save it locally.”

The key is to make the acceptance criteria clear: the image should be relevant to the article topic, the size should be 1K, and the save path should be fixed.

Step 2: Let the Model Find the Documentation and Write the Code

The model’s execution path is: based on the API platform I describe, automatically locate the calling method, generate the calling script, and handle authentication and error retries. I only need to confirm two things in the generated code: whether the key is read from an environment variable, and whether the request parameters match the documentation.

Step 3: Integration Testing and Iteration

The first generated image is often not ideal. At this point, do not modify the code yourself. Instead, feed back “what is unsatisfactory” to the model—for example, “the image is too abstract; I want it flatter and more technical.” The model will automatically adjust the prompt wording and add style constraints. After two or three rounds of iteration, the image quality becomes stable.

Final Thoughts

This case demonstrates one thing: ordinary creators can use AI coding tools to turn “calling APIs”—a capability that used to belong to developers—into part of their daily productivity. You do not need to be a programming expert. You only need to describe requirements clearly and understand how to validate results.

Next, you can extend this skill further: batch-process multiple articles, automatically upload images to object storage and write back links, or preset different visual styles for different sections. The boundary of the skill depends on the boundary of your imagination and description ability—this is precisely the best gift this era offers to creators.