Escribir, revisar y editar código, así como responder preguntas sobre él, es uno de los principales casos de uso de los modelos de OpenAI en la actualidad. Esta guía presenta tus opciones para generar código con gpt-6-astra y Codex.
Codex es el agente de programación de OpenAI para el desarrollo de software. Te ayuda a escribir, revisar y depurar código. Interactúa con Codex a través de distintas interfaces: en tu IDE, mediante la CLI, en sitios web y móviles, o en tus pipelines de CI/CD con el SDK. Codex es la mejor manera de incorporar ingeniería de software con agentes a tus proyectos.
Codex funciona mejor con los modelos de propósito general más recientes, como gpt-5.6. Ofrecemos una variedad de modelos diseñados específicamente para trabajar con agentes de programación como Codex, entre ellos gpt-5.3-codex, pero recomendamos usar el modelo de propósito general más reciente para la mayoría de las tareas de generación de código.
Consulta la documentación de ChatGPT para encontrar guías de configuración, material de referencia, precios y más información.
Para la mayoría de las tareas de generación de código mediante la API, comienza con gpt-6-astra. Se encarga tanto de tareas de propósito general como de programación, por lo que es una excelente opción predeterminada cuando tu aplicación necesita escribir código, razonar sobre requisitos, consultar documentación y gestionar flujos de trabajo más amplios en un solo lugar.
Este ejemplo muestra cómo puedes usar la API Responses en un caso de uso de generación 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" }
}'
Nuestros modelos de la familia GPT-5 se destacan en el desarrollo frontend, sobre todo cuando se combinan con un arnés de ejecución para agentes de programación como Codex.
Las aplicaciones de demostración que se muestran a continuación se generaron de una sola vez, es decir, a partir de un único prompt y sin código escrito a mano. Úsalas para evaluar la calidad de la generación de frontend y los patrones de prompts para flujos de trabajo de generación de código centrados en interfaces de usuario.
- Consulta la documentación de ChatGPT para descubrir qué puedes hacer con Codex, configurarlo en la interfaz que elijas u obtener más detalles.
- Consulta la Guía de modelos para conocer las opciones de selección de modelos, sus funciones, las recomendaciones de migración y los patrones de diseño de prompts que funcionan bien en tareas de programación y con agentes.
- Compara
gpt-6-astra y gpt-5.3-codex en las páginas de los modelos.
