Hoje, um dos principais usos dos modelos da OpenAI é escrever, revisar e editar código, além de responder a perguntas sobre ele. Este guia apresenta as opções para gerar código com o gpt-6-astra e o Codex.
O Codex é o agente de programação da OpenAI para desenvolvimento de software. Ele ajuda você a escrever, revisar e depurar código. Você pode interagir com o Codex no seu IDE, pela CLI, em sites para desktop e dispositivos móveis ou nos seus pipelines de CI/CD usando o SDK. O Codex é a melhor maneira de usar agentes de IA nos seus projetos de engenharia de software.
O Codex funciona melhor com os modelos de uso geral mais recentes, como o gpt-6.1-sol.
Consulte a documentação do ChatGPT para ver guias de configuração, material de referência, preços e outras informações.
Para a maioria das tarefas de geração de código via API, comece com o gpt-6-astra. Ele dá conta tanto de tarefas gerais quanto de programação. Por isso, é uma boa escolha padrão quando seu aplicativo precisa escrever código, analisar requisitos, consultar a documentação e executar fluxos de trabalho mais amplos em um só lugar.
Este exemplo mostra como usar a API Responses para gerar 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" }
}'
Para desenvolver o front-end, comece com o gpt-6.1-sol ou o gpt-6-astra no Codex ou na API Responses.
A galeria histórica do GPT-5 reúne aplicativos gerados a partir de um único prompt cada. Use esses prompts como ponto de partida e avalie os resultados com o modelo que você pretende implantar.
- Acesse a documentação do ChatGPT para saber o que você pode fazer com o Codex, configurá-lo na interface de sua preferência ou consultar mais detalhes.
- Consulte o guia de modelos para saber como escolher um modelo, conhecer seus recursos, planejar a migração e usar padrões de prompts que funcionam bem em tarefas de programação e em tarefas com agentes de IA.
- Compare o
gpt-6-astra e o gpt-6.1-sol nas respectivas páginas dos modelos.
