Die Arbeit mit Code gehört heute zu den wichtigsten Einsatzgebieten der Modelle von OpenAI. Sie können Code schreiben, überprüfen und bearbeiten sowie Fragen dazu beantworten. Dieser Leitfaden zeigt dir, welche Möglichkeiten du mit gpt-6-astra und Codex zur Codegenerierung hast.
Codex ist der Programmieragent von OpenAI für die Softwareentwicklung. Er hilft dir, Code zu schreiben, zu überprüfen und zu debuggen. Du kannst mit Codex in deiner IDE, über die CLI, im Web oder auf mobilen Websites arbeiten. Mit dem SDK kannst du Codex auch in deinen CI/CD-Pipelines nutzen. Codex ist die beste Möglichkeit, Agenten in deinen Softwareprojekten einzusetzen.
Codex funktioniert am besten mit den neuesten Allzweckmodellen wie gpt-6.1-sol.
In der ChatGPT-Dokumentation findest du Anleitungen zum Einrichten von Codex, Referenzmaterial, Preise und weitere Informationen.
Wenn du Code über die API generierst, beginne für die meisten Aufgaben mit gpt-6-astra. Das Modell eignet sich sowohl für allgemeine Aufgaben als auch zum Programmieren. Es ist eine gute erste Wahl, wenn deine Anwendung Code schreiben, Anforderungen analysieren, Dokumentation prüfen und umfassendere Arbeitsabläufe abdecken soll.
Das folgende Beispiel zeigt, wie du mit der Responses API Code generierst.
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" }
}'
Beginne bei der Frontend-Entwicklung mit gpt-6.1-sol oder gpt-6-astra. Beide Modelle kannst du in Codex oder über die Responses API nutzen.
Die historische GPT-5-Galerie zeigt Anwendungen, die jeweils aus einem einzigen Prompt entstanden sind. Nutze die Prompts als Ausgangspunkt und bewerte die Ergebnisse mit dem Modell, das du einsetzen möchtest.
- In der ChatGPT-Dokumentation erfährst du, was du mit Codex tun kannst und wie du Codex in der Oberfläche deiner Wahl einrichtest. Dort findest du auch weitere Details.
- Im Leitfaden zu den Modellen findest du Informationen zur Modellauswahl, zu Funktionen und zur Migration sowie Prompt-Muster, die sich für Programmieraufgaben und die Arbeit mit Agenten eignen.
- Vergleiche
gpt-6-astra und gpt-6.1-sol auf den jeweiligen Modellseiten.