Escribir, revisar y editar código, así como responder preguntas sobre él, son algunos de los usos principales de los modelos de OpenAI en la actualidad. Esta guía explica qué opciones tienes 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. Puedes interactuar con Codex desde tu IDE, a través de la CLI, en sitios web y móviles o desde tus pipelines de CI/CD con el SDK. Codex es la mejor forma de incorporar agentes de ingeniería de software a tus proyectos.
Codex funciona mejor con los modelos de propósito general más recientes, como gpt-6.1-sol.
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, empieza con gpt-6-astra. Este modelo puede realizar tanto tareas de propósito general como tareas de programación. Por eso es una buena opción predeterminada cuando tu aplicación necesita escribir código, analizar 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 de Responses para generar 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 el desarrollo frontend, empieza con gpt-6.1-sol o gpt-6-astra en Codex o en la API de Responses.
La galería histórica de GPT-5 muestra aplicaciones generadas a partir de un solo prompt cada una. Usa los prompts como punto de partida y evalúa los resultados con el modelo que planeas desplegar.
- Visita la documentación de ChatGPT para descubrir qué puedes hacer con Codex, configurarlo en la interfaz que elijas u obtener más información.
- Lee la guía de modelos para conocer los criterios de selección, las funciones, las pautas de migración y los patrones de prompts que funcionan bien en tareas de programación y tareas con agentes.
- Compara
gpt-6-astra y gpt-6.1-sol en las páginas de cada modelo.
