Code schreiben, überprüfen und bearbeiten sowie Fragen dazu beantworten: Das gehört heute zu den wichtigsten Anwendungsfällen für OpenAI-Modelle. Dieser Leitfaden zeigt dir deine Möglichkeiten zur Codegenerierung mit gpt-6-astra und Codex.
Codex ist der Coding-Agent von OpenAI für die Softwareentwicklung. Er hilft dir, Code zu schreiben, zu überprüfen und Fehler zu beheben. Du kannst über verschiedene Oberflächen mit Codex arbeiten: in deiner IDE, über die CLI, auf Websites und mobilen Websites oder mit dem SDK in deinen CI/CD-Pipelines. Codex ist die beste Möglichkeit, agentische Softwareentwicklung in deinen Projekten einzusetzen.
Codex funktioniert am besten mit den neuesten Allzweckmodellen wie gpt-5.6. Wir bieten eine Reihe von Modellen an, die speziell für die Zusammenarbeit mit Coding-Agenten wie Codex entwickelt wurden, etwa gpt-5.3-codex. Für die meisten Aufgaben zur Codegenerierung empfehlen wir jedoch das neueste Allzweckmodell.
In der ChatGPT-Dokumentation findest du Setup-Anleitungen, Referenzmaterial, Preise und weitere Informationen.
Für die meisten Aufgaben zur API-basierten Codegenerierung solltest du mit gpt-6-astra beginnen. Das Modell bewältigt sowohl allgemeine Aufgaben als auch Programmieraufgaben. Damit ist es eine gute Standardwahl, wenn deine Anwendung an einem Ort Code schreiben, Anforderungen durchdenken, Dokumentation durchsehen und umfassendere Arbeitsabläufe abwickeln soll.
Dieses Beispiel zeigt, wie du die Responses API zur Codegenerierung einsetzen kannst:
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" }
}'
Unsere Modelle der GPT-5-Familie sind besonders stark in der Frontend-Entwicklung, vor allem in Kombination mit einem Harness für Coding-Agenten wie Codex.
Die folgenden Demoanwendungen wurden per One-Shot-Generierung erstellt, also aus jeweils einem einzigen Prompt und ohne von Hand geschriebenen Code. Nutze sie, um die Qualität der Frontend-Generierung und Prompt-Muster für Arbeitsabläufe zur Codegenerierung mit Schwerpunkt auf Benutzeroberflächen zu beurteilen.
- In der ChatGPT-Dokumentation erfährst du, was du mit Codex tun kannst, wie du Codex in der Oberfläche deiner Wahl einrichtest, und findest weitere Details.
- Lies den Modellleitfaden, um mehr über Modellauswahl, Funktionen, Migration und Prompt-Muster zu erfahren, die sich für Programmieraufgaben und agentische Aufgaben eignen.
- Vergleiche
gpt-6-astra und gpt-5.3-codex auf den Modellseiten.
