Escrever, revisar e editar código, além de responder a perguntas sobre ele, é um dos principais casos de uso dos modelos da OpenAI atualmente. Este guia apresenta suas opções para geração de código com gpt-6-astra e Codex.
O Codex é o agente de programação da OpenAI para desenvolvimento de software. Ele ajuda você a escrever, revisar e depurar código. Interaja com o Codex em diversas interfaces: na sua IDE, pela CLI, em sites para Web e dispositivos móveis ou nos seus pipelines de CI/CD com o SDK. O Codex é a melhor maneira de incorporar a engenharia de software agêntica aos seus projetos.
O Codex funciona melhor com os modelos de uso geral mais recentes, como gpt-5.6. Oferecemos diversos modelos projetados especificamente para trabalhar com agentes de programação como o Codex, a exemplo de gpt-5.3-codex, mas recomendamos usar o modelo de uso geral mais recente para a maioria das tarefas de geração de código.
Consulte a documentação do ChatGPT para encontrar guias de configuração, material de referência, preços e mais informações.
Para a maioria dos casos de geração de código via API, comece com gpt-6-astra. Ele lida tanto com tarefas de uso geral quanto com programação, o que o torna uma ótima opção padrão quando seu aplicativo precisa escrever código, raciocinar sobre requisitos, consultar documentação e executar fluxos de trabalho mais amplos em um só lugar.
Este exemplo mostra como usar a Responses API em um caso de uso de geração de código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import OpenAI from "openai";
const openai = new OpenAI();
const result = await openai.responses.create({
model: "gpt-6-astra",
input: `Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))
`,
reasoning: { effort: "high" },
});
console.log(result.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17from openai import OpenAI
client = OpenAI()
result = client.responses.create(
model="gpt-6-astra",
input="""Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))
""",
reasoning={"effort": "high"},
)
print(result.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
"github.com/openai/openai-go/v3/shared"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(`Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))`)},
Reasoning: shared.ReasoningParam{Effort: shared.ReasoningEffortHigh},
})
if err != nil {
panic(err)
}
fmt.Println(response.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.ResponseCreateParams;
String code =
"""
def display_name(user):
return user.profile.name
print(display_name(None))
""";
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input("Find the null pointer exception in this code:\n\n" + code)
.reasoning(Reasoning.builder().effort(ReasoningEffort.HIGH).build())
.build();
client.responses().create(params).output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29using OpenAI.Responses;
#pragma warning disable OPENAI001
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);
CreateResponseOptions options = new()
{
Model = "gpt-6-astra",
ReasoningOptions = new ResponseReasoningOptions
{
ReasoningEffortLevel = ResponseReasoningEffortLevel.High,
},
};
options.InputItems.Add(
ResponseItem.CreateUserMessageItem(
"""
Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))
"""
)
);
ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17require "openai"
client = OpenAI::Client.new
code = <<~PYTHON
def display_name(user):
return user.profile.name
print(display_name(None))
PYTHON
response = client.responses.create(
model: "gpt-6-astra",
input: "Find the null pointer exception in this code:\n\n#{code}",
reasoning: { effort: :high }
)
puts(response.output_text)
1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"input": "Find the null pointer exception in this code:\n\ndef display_name(user):\n return user.profile.name\n\nprint(display_name(None))\n",
"reasoning": { "effort": "high" }
}'
Nossos modelos da família GPT-5 se destacam no desenvolvimento frontend, principalmente quando combinados com um harness de agente de programação como o Codex.
Os aplicativos de demonstração abaixo foram gerados em uma única tentativa, ou seja, a partir de um único prompt, sem código escrito à mão. Use-os para avaliar a qualidade da geração de frontend e os padrões de prompt para fluxos de trabalho de geração de código com forte foco em interfaces de usuário.
- Acesse a documentação do ChatGPT para descobrir o que você pode fazer com o Codex, configurar o Codex na interface de sua preferência ou encontrar mais detalhes.
- Leia as Orientações sobre modelos para saber mais sobre seleção de modelos, recursos, orientações de migração e padrões de criação de prompts que funcionam bem em tarefas de programação e tarefas agênticas.
- Compare
gpt-6-astra e gpt-5.3-codex nas páginas dos modelos.
