HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

DSLはLLMの信頼性の高い使用を可能にする

DSLs Enable Reliable Use of LLMs (martinfowler.com)

72 pointsby SirOibaf46 コメント

要約

大規模言語モデル(LLM)はコードを高速に生成できますが、意図した通りに生成されることを保証するには明確な境界が必要です。ドメイン固有言語(DSL)は、LLMを最初から正しく導く強力なハーネスを提供します。Tickloomのような分散システム動作を説明するためのドメインモデルとDSLの例は、LLMをDSLを反復的に構築するパートナーとして、またそれを使用するための自然言語インターフェースとしてどのように使用できるかを示しています。このようなDSLは、LLMの世界におけるソフトウェアシステムの主要な真実の情報源として機能します。

全文翻訳

DSLがLLMの信頼性の高い利用を可能にする

現代のLLMは驚異的な能力を持っています。自然言語の指示から大量のコード、時にはシステム全体を生成できます。ここで重要なのは、「構築すべきものの意図」が、LLMがコーディングの構成要素にマッピングできる正確な言葉で明確に表現されているという前提です。しかし、考慮すべき重要な点が2つあります。それは、事前の仕様の限界と、実装を通じて設計がいかに発見されるかということです。

事前仕様の限界

大規模システムの構築には、多くの小さな設計上の決定が伴いますが、これらすべてを事前に知ったり、高レベルの仕様から完全に導き出したりすることはできません。仕様とは、せいぜい最初の仮説にすぎません。実際の制約、トレードオフ、エッジケースは、実装を進めるにつれて、反復的に発見されます。これは以前の記事で詳しく議論し、「事前の仕様の不可能性」と呼びました。仕様が無価値だということではなく、最初の仕様は改訂されるべき仮説であり、完成した設計図ではないということです。

自然な対応は、反復することです。仕様を洗練させ、コードを生成し、返ってきたものをレビューし、学んだことを次のラウンドにフィードバックします。このループは、各ラウンドが小さくレビュー可能な変更を生み出す場合にうまく機能します。

設計は実装を通じて発見される

コードのレビュー、特に設計がまだ発見されていない段階でのレビューは、コードを書くこととは異なります。生成されたコードをレビューする際、私たちはチャンクを検証し、それが意図にマッピングしているかを確認し、潜在的な落とし穴を探します。しかし、レビューが設計上の決定に苦悩を強いることはめったにありません。対照的に、コードを書くことは、責任がどこに属するか、または設計をさらに拡張するためにどの境界を公開すべきかといった具体的な決定を考え抜くことを私たちに強います。これらの決定を下すことによって、設計は最も完全に明らかになります。

私たちがコーディングするプログラミング言語とパラダイムは、得られる設計上の洞察を形作ります。関数型設計アプローチやオブジェクト指向設計アプローチは、パラダイムに自然なイディオムやパターンとともに、設計の異なる側面を明らかにします。

では、LLMはどこに位置するのでしょうか?私はLLMが2つの役割を果たすと考えています。それらは、設計とその語彙を形成する上で大きな助けとなり、設計空間を探索し、適切な抽象化を発見するのを助けるブレインストーミングパートナーとして機能します。語彙が確立されたら、LLMはそれに優れた自然言語インターフェースとして機能します。

ドメイン抽象化とDSL

これをフレーム化する有用な方法は、ドメイン駆動設計(DDD)を通じたものです。その核心的な洞察は、ドメインの共有概念モデルをコードで構築し、そのモデル(DDDではユビキタス言語と呼びます)を使用してコードベースを進化させ、チームに思考とコミュニケーションのための語彙を与えることです。多くの場合、そのモデルの上にドメイン固有言語(DSL)を構築することが非常に効果的です。これは、ドメインの概念と操作を表現するための制約された構文です。このように見ると、ほとんどの開発はドメインモデルを構築し、それを使用してシステムを進化させるプロセスです。LLMは、ドメインモデルが既に存在するかどうかに応じて、2つの異なる役割を果たします。この記事では、ドメイン固有言語(DSL)がLLMとどのように機能するかを中心に説明します。

なぜDSLはLLMと非常にうまく機能するのか

DSLがLLMとうまく機能することは一般的な経験です。PlantUML、Mermaid、Graphvizは視覚モデリングのためのドメイン固有言語です。SQLはデータベースクエリのためのDSLです。Kubernetes YAMLはクラウドインフラストラクチャを記述するためのDSLです。これらは汎用プログラミング言語ではありません。それらは意図的に制約されており、1つのドメインの狭い範囲の概念を表現するように設計されています。そして、LLMがプレーンな英語の説明からMermaidダイアグラム、SQLクエリ、またはKubernetesマニフェストを生成するのに驚くほど優れていることは驚くことではありません。

私の観察では、DSLはLLMにコンテキスト内のいくつかの例に非常によく応答するため、LLMをより信頼性の高いものにします。Javaのような汎用言語は、同じ意図を表現するための多くの有効な方法を提供します。DSLはバリエーションを取り除きます。モデルにいくつかの例を与えるだけで、正しい構文を確実に生成できます。最前線のモデルは、トレーニング中にPlantUMLやJavaの流暢なインターフェースにすでに大量にさらされているため、ゼロから始めているわけではないことに注意する価値があります。真に新しいDSLをタスクとする場合に、より小さく、より制約されたモデルがどのようにパフォーマンスを発揮するかを見るのは興味深いでしょう。

エージェント(単一ショット生成ではなく、自律的な生成・チェックループで実行されるLLM)にとっては、もう1つの利点があります。DSLはほぼ常に決定論的なバリデーター(パーサー、JSONスキーマ、型チェッカー、またはコンパイラ)を同梱しています。エージェントは候補を生成し、バリデーターに実行させ、エラーから修正することができます。これらすべてを人間の介入なしに行えます。重要なのは、エラーが生成されたコードの奥深くに埋め込まれたスタックトレースではなく、ドメインレベルで表現されることです。「クライアントを選択する前にアクションを選択することはできません」といった具合です。DSLのツールセット自体が優れたハーネスとして機能します。これは、以下のTickloomの例で具体的に確認できます。ここでは、DSLの文法はホスト言語のコンパイラによって強制され、結果の実行は自動的にチェックされます。

これは万能の解決策ではないことに注意することが重要です。DSLが十分に小さく制約されており、いくつかのコンテキスト内の例でその使用法を伝えることができる限り、この利点は持続します。また、言語とそのセマンティックモデルの設計と保守には、かなりの初期コストがかかります。したがって、その報酬は、バリデーターによってサポートされる、適切にファクタリングされた、真に制約されたDSLに集中します。

例:LLMを使用してダイアグラムリッチなPowerPointプレゼンテーションを生成する

LLMはカスタムツールを構築するのを非常に簡単にします。分散システムを教える際、私は頻繁にプレゼンテーションを作成する必要がありますが、そのほとんどはクラスター内の分散操作を説明するダイアグラムを含んでいます。UMLシーケンスダイアグラムはそれには最適でしたが、クラスターを通過するメッセージフローを説明しながら完全なシーケンスダイアグラムを表示することはあまり役に立ちませんでした。私はPowerPointプレゼンテーションでシーケンスダイアグラムをステップバイステップで表示するツールが必要でした。LLMの助けを借りて、プレゼンテーション構造をYAMLで記述し、PlantUMLダイアグラムへの参照を含むツールを構築することができました。PlantUMLダイアグラムはステップでマークされており、ツールは各ステップに個別のスライドを生成します。これにより、ダイアグラムリッチなプレゼンテーションを簡単に作成できました。

3つのノード(athens、byzantium、cyrene)のクラスターを示す、ステップを示すPlantUMLシーケンスダイアグラムを生成してください。クラスターをマークするボックスを配置してください。アクターAliceがメッセージ「title」、「After Dawn」をathensに送信します。Athensは自身にメッセージを送信します。状態「title: After Dawn」を示すノートを配置してください。Athensはbyzantiumにメッセージを送信しますが、失敗します。Athensはcyreneに送信します。cyreneの右側に配置されたノートを配置してください。次にAthensはisQuorumReachedをチェックし、Aliceに同期Success矢印を返します。各メッセージの後に「[step]マーカーを配置してください。

このプロンプトは、ステップマーカー付きの以下のPlantUMLコードを生成します。

@startuml
actor Alice

box "Cluster" #lightblue
participant athens
participant byzantium
participant cyrene
end box

'[step]
Alice -> athens: "title", "After Dawn"

'[step]
athens -> athens: save()

note right of athens
  state:
  title: After Dawn
end note

'[step]
athens -[#red]x byzantium: "title", "After Dawn"

'[step]
athens -> cyrene: "title", "After Dawn"

note right of cyrene
  state:
  title: After Dawn
end note

'[step]
athens -> athens: isQuorumReached()

'[step]
athens --> Alice: Success

@enduml

私はこれを使用して、PowerPointプレゼンテーションで一連のスライドを作成しました。そのために、プレゼンテーション構造と各スライドで使用されるダイアグラムを記述するための小さなYAML仕様を開発しました。これにより、LLMを使用して、手動でアニメーションを作成することなく、複雑な分散システム概念を説明するプレゼンテーションを作成することができました。スライドYAML仕様を生成するための例のプロンプトは、次のとおりシンプルです。

「quorum-write」というダイアグラムを参照し、「Quorum Write Example」というタイトルを持つスライドYAMLを作成してください。

これは、次のようなスライド仕様YAMLを生成します。

- slide:
    title: "Quorum Write Example"
    diagram: "quorum-write"

プロンプトがスライドYAMLを作成するように指示していても、それがランダムなYAML仕様ではないことに注意することが重要です。PowerPointプレゼンテーションを生成するツールと、ツールが理解するYAML仕様がプロンプトのコンテキストとして使用されるため、LLMはツールが直接使用できる正しいYAML仕様を生成できます。

完全なYAML仕様は、このGithubリポジトリで表示できます。

この単一の例で、LLMが2つの異なる役割を果たしたことに注意してください。まず、既存のPlantUMLツールのの上に、ステップマーク付きのPlantUML拡張機能とスライドYAMLを形成する共同設計者でした。次に、その小さなDSLが存在すると、それは英語のリクエストを有効な仕様に変換する自然言語インターフェースになりました。この記事の最後で、この労働の分担に戻ります。

セマンティックモデルの構築

前のセクションでカバーした例は単純でした。YAMLはキャリア構文として使用され、その解析構文ツリーを直接処理しました。これにより、構文ツリー自体をセマンティックモデルとして使用しました(ただし、これは構文を実行セマンティクスに結合します)。しかし、分散システムのようなより複雑なドメインでは、ドメインの概念とコードベースで行われた設計上の決定を表すためにより複雑なセマンティックモデルが必要です。ここでは、私が構築した小さなフレームワークに基づいた例を見てみましょう。これは、分散システムを迅速に構築およびテストするためのものです。

例:Tickloom — 分散システムのためのセマンティックモデル

クォーラムベースのキーバリューストアやRaftやPaxosのようなコンセンサスプロトコルなどの分散システムの実装は、 daunting なタスクです。プロンプト、仕様、または慎重に構築された.mdスキルファイルを通じて段階的に実装がガイドされたとしても、非同期ランタイムは実装上の決定の圧倒的な空間を露出させます。スレッドモデル、ネットワーキングパターン、ストレージコーディネーション、リトライ動作、タイミングセマンティクスはすべて生成されたコード内に絡み合ったままです。問題は単なるコード生成の複雑さではなく、検証の複雑さです。スレッドスケジューリング、ネットワーク遅延、プロセスの一時停止、クロックスキューによるすべての可能なインターリービングによって作成される結果の状態空間は非常に大きくなり、すべての相互作用する動作全体を体系的にレビューおよび検証することはほぼ不可能になります。これが、Jepsenテストが最もバトルテストされた分散システムでもバグを見つける理由です。

これはまさにセマンティックモデルが有益な場所です。Tickloomは、分散アルゴリズムを構築およびテストするために私が構築した小さなフレームワークです。その抽象化は汎用ランタイムではありません。それらは、分散プロセスがどのように動作するかについての設計上の決定のセットです。各ノードはシングルスレッドのティックループで実行されます。tick()への各呼び出しは、論理クロックを1つ進め、固定された決定論的な順序(ネットワーク、メッセージバス、プロセス、ストレージ)で保留中の作業を処理します。時間はミリ秒ではなくティックで測定されます。メッセージはプレーンなJavaレコードです。レプリカ間のコーディネーションは、ピア、ブロードキャスト、クォーラムについて既に知っているReplica基底クラスを通じて表現されます。

スレッド、タイミング、ネットワーク配信は、もはや各プロンプトで再決定されるべき開かれた問題ではありません。アルゴリズム作成者にとって残るのは、実際のプロトコルロジックです。たとえば、クォーラムレプリカは、フレームワークの語彙で表現されたメッセージハンドラーのセットにすぎません。

フレームワークが語彙(Replica、quorumRequest、countResponseIf、MessageType、Handler)を提供するため、プロンプトは配管ではなくプロトコルのレベルに留まることができます。

Tickloom Replica抽象化を使用して、クォーラムベースのキーバリューストアを実装してください。クライアントGETは、多数から値を取得し、最も高いタイムスタンプ(ラストライターウィン)を持つものを返す必要があります。タイムスタンプが格納されているものより新しい場合のみ、ローカルに書き込みを適用してください。

この高レベルの説明は、次のようなコードを生成します。

@Override
protected Map<MessageType, Handler> initialiseHandlers() {
    return Map.of(
            LWWMessageType.CLIENT_SET_REQUEST, this::handleClientSetRequest,
            LWWMessageType.CLIENT_GET_REQUEST, this::handleClientGetRequest,
            LWWMessageType.INTERNAL_SET_REQUEST, this::handleInternalSetRequest,
            LWWMessageType.INTERNAL_GET_REQUEST, this::handleInternalGetRequest,
            LWWMessageType.INTERNAL_SET_RESPONSE, this::handleInternalSetResponse,
            LWWMessageType.INTERNAL_GET_RESPONSE, this::handleInternalGetResponse
    );
}

private void handleClientGetRequest(Message message) {
    var req = deserializePayload(message.payload(), ClientGetRequest.class);
    var internalReq = new InternalGetRequest(req.key());

    this.<InternalGetResponse>quorumRequest(LWWMessageType.INTERNAL_GET_REQUEST, internalReq) 
            .countResponseIf(r -> true) // any response is fine, just need a majority
            .send()
            .whenComplete((responses, error) -> {
                if (error != null) {
                    send(createMessage(message.source(), 
                                       message.correlationId(), 
                                       new ClientGetResponse(req.key(), null, false),
                                       LWWMessageType.CLIENT_GET_RESPONSE));
                    return;
                }

                byte[] highestValue = null;
                long highestTimestamp = -1;

                for (InternalGetResponse r : responses.values()) {
                    if (r.value() != null && r.timestamp() > highestTimestamp) {
                        highestTimestamp = r.timestamp();
                        highestValue = r.value();
                    }
                }

                boolean found = highestValue != null;
                send(createMessage(message.source(), 
                                   message.correlationId(), 
                                   new ClientGetResponse(req.key(), highestValue, found),
                                   LWWMessageType.CLIENT_GET_RESPONSE));
            });
}

ソース

セマンティックモデル自体がコンテキストとして機能します。プロンプトはコードベースに具体的な型として存在する概念を名前で指定するため、LLMはスレッドモデルやネットワーキングレイヤーを発明しているのではなく、固定されよく理解された基盤に対してプロトコルロジックを埋め込んでいます。

抽象化が役立つ — DSLなしでも

DSLはスペクトルの片端であり、構築は容易ではありません。独自の言語に手を伸ばす前に、クリーンな抽象化のセットがすでに同じアイデアの軽量バージョンであることに注意する価値があります。そして、フレームワークが上記のクォーラムストアの語彙を提供したのと同様に、ライブラリの名前付き型とメソッド自体がモデルを接地できる語彙です。Tickloomのセマンティックモデルは、実際には4つのシーム(計算とメッセージ処理のためのProcess/Replica、通信のためのNetwork、永続化のためのStorage、および時間のための論理的なClock)にすぎません。そして、その分解は新しい構文なしでほとんどの作業を行います。

これが、DSLだけでなく抽象化もLLMとペアになる理由です。「Tickloom ReplicaとしてRaftを実装する」というプロンプトは、探求すべき状態空間が限られています。既存のQuorumReplicaは、コンテキスト内の作業例として使用できます。

例:分散システムのシナリオをテストするためのDSLの構築

アルゴリズムの実装は1つのことですが、それを実行することは別のことです。分散システムの微妙なバグは特定の順序に存在します。リーダーのクォーラムがシフトする前にレプリケートされる書き込み、ちょうど悪い瞬間に回復するパーティション、クロックがずれた2つのコーディネーター。そのようなシナリオをテストキットに対して直接書くことは、Futureや手動のtick()ループを扱うことを含みます。これは、そのように書かれたクロックスキューシナリオです。

Cluster cluster = new Cluster()
        .withProcessIds(Arrays.asList(ATHENS, BYZANTIUM, CYRENE))
        .useSimulatedNetwork()
        .build(QuorumReplica::new);

cluster.start();

try {
    cluster.tickUntil(cluster::areAllNodesInitialized);

    cluster.setTimeForProcess(ATHENS, 1000L);
    cluster.setTimeForProcess(BYZANTIUM, 2000L);

    QuorumReplicaClient alice = cluster.newClientConnectedTo(ALICE, ATHENS, QuorumReplicaClient::new);
    QuorumReplicaClient bob = cluster.newClientConnectedTo(BOB, BYZANTIUM, QuorumReplicaClient::new);
    QuorumReplicaClient reader = cluster.newClientConnectedTo(READER, ATHENS, QuorumReplicaClient::new);

    TickCompletableFuture<SetResponse> bobWrite = bob.set(KEY.getBytes(StandardCharsets.UTF_8), "B".getBytes(StandardCharsets.UTF_8));
    cluster.tickUntilComplete(bobWrite);

    TickCompletableFuture<SetResponse> aliceWrite = alice.set(KEY.getBytes(StandardCharsets.UTF_8), "A".getBytes(StandardCharsets.UTF_8));
    cluster.tickUntilComplete(aliceWrite);

    TickCompletableFuture<GetResponse> read = reader.get(KEY.getBytes(StandardCharsets.UTF_8));
    cluster.tickUntilComplete(read);

    assertEquals("B", new String(read.getResult().value(), StandardCharsets.UTF_8));
} finally {
    cluster.close();
}

ソース

意図 — 「BobはByzantium経由で書き込み、AliceはAthens経由で書き込み、ReaderはBobの値を見る(Byzantiumのクロックが先行していたため)」 — は、メカニズムの下に埋もれています。これも検証が難しいコードです。多数の付随的な決定(いつティックするか、バイトをエンコードする方法、どのファクトリオーバーロードを呼び出すか)があり、LLMが微妙に間違える可能性があり、レビュー担当者はそれらすべてをチェックする必要があります。

そこで、セマンティックモデルの上に、シナリオ自体の語彙 — サーバー、クライアント、誰が誰に接続されているか、各クライアントが何をするか、そしてそれが実行されている間にどの障害が発生しているか — を持つ内部DSLを構築しました。同じシナリオは次のようになります。

        Scenario<QuorumReplicaClient> scenario =                        
                        QuorumStepBuilder.scenario("LWW lost update via server clock skew")
                        .servers(ATHENS, BYZANTIUM, CYRENE)
                        .clients(ALICE, BOB, READER)
                        .client(ALICE).connectedTo(ATHENS)
                        .client(BOB).connectedTo(BYZANTIUM)
                        .given(g -> g.serverTimeAt(ATHENS, 1_000L)
                                     .serverTimeAt(BYZANTIUM, 2_000L))
                        .steps(s -> {
                            s.client(BOB).writes(KEY, "B").expectSuccess();
                            s.client(ALICE).writes(KEY, "A").expectSuccess();

                            s.client(READER).reads(KEY)
                                    .expectResponse(v -> "B".equals(v));
                        });

ソース

DSLは薄く宣言的な表面であり、純粋な中間表現 — Stepで構成されるScenario — にコンパイルされます。各ステップはAction(読み取りまたは書き込み)とオプションのClusterEvent(パーティションやメッセージ遅延などの障害)を運びます。障害は英語としても読み取れます:partition(BYZANTIUM).from(CYRENE)、reconnect(BYZANTIUM)、delay(INTERNAL_SET_REQUEST).from(ATHENS).to(BYZANTIUM, CYRENE).byTicks(100)。文法は、プログレッシブインターフェースを通じて型システムによって強制されます — トポロジの前にステップを宣言したり、クライアントを選択する前にアクションを宣言したりすることはできません — そのため、不正なシナリオのクラス全体がコンパイルされません。DSLはJavaで構築された内部DSLであるため、ホストコンパイラは文法を無料で検証し、不正な生成はランタイムの驚きではなく、不正なステップにピン留めされたコンパイルエラーとして返されます。

DSLが存在すると、障害シナリオの自然言語記述はほぼ直接それにマッピングされます。次のようなプロンプト:

TickloomシナリオDSLを使用して、DDIA §10.6の非線形化可能なクォーラム読み取りを再現するシナリオを記述してください。Athensに接続されたライターはキーを設定し、次にAthensから他のレプリカへのレプリケーションが遅延している間にそれを更新します。Byzantium経由で読み取るAliceは、Athensを含むクォーラムに強制され、新しい値を見ます。その後、ByzantiumとCyreneのクォーラム経由で読み取るBobは、古い値を見ます。

次のような、DSLの制約された語彙内に完全に収まるシナリオを生成します。

Scenario<QuorumReplicaClient> scenario =
        QuorumStepBuilder.scenario("Non-linearizable quorum read")
                .servers(ATHENS, BYZANTIUM, CYRENE)
                .clients(WRITER, ALICE, BOB)
                .client(WRITER).connectedTo(ATHENS)
                .client(ALICE).connectedTo(BYZANTIUM)
                .client(BOB).connectedTo(BYZANTIUM)
                .steps(s -> {
                    // Writer sets the key to VOLD initially and it replicates fully
                    s.client(WRITER).writes(KEY, VOLD).expectSuccess();

                    // Writer updates to VNEW, but replication from Athens is delayed
                    s.client(WRITER).writes(KEY, VNEW)
                            .whileClusterEvent(delay(QuorumMessageTypes.INTERNAL_SET_REQUEST)
                                    .from(ATHENS).to(BYZANTIUM, CYRENE).byTicks(100))
                            .expectSuccess();

                    // Alice reads through Byzantium. Force quorum to include Athens by partitioning Cyrene.
                    // She will read VNEW from Athens.
                    s.client(ALICE).reads(KEY)
                            .whileClusterEvent(partition(BYZANTIUM).from(CYRENE))
                            .expectResponse(v -> VNEW.equals(v));

                    // Bob reads later through Byzantium. Force quorum to include Cyrene (and exclude Athens).
                    // The delayed VNEW replication hasn't arrived at Cyrene, so Bob reads VOLD.
                    s.client(BOB).reads(KEY)
                            .whileClusterEvent(reconnect(BYZANTIUM))
                            .whileClusterEvent(partition(BYZANTIUM).from(ATHENS))
                            .expectResponse(v -> VOLD.equals(v));
                });

ScenarioResult result = scenario.run();

ソース

表面が非常に小さく — そして生成できる有効なコードの空間が有効なJavaプログラムの空間よりもはるかに小さいため — LLMが幻覚を起こす余地はほとんどなく、レビュー担当者は結果を監査するコードとしてではなく、実験の説明として読むことができます。LLMが幻覚を起こしたとしても、内部DSLはコンパイルに失敗し、LLMが間違いを修正できるようになります。

LLMとの作業における2つのフェーズ

上記で議論された例からパターンが現れます。それらのそれぞれで、LLMは2つの非常に異なる方法で役立ちました。

最初のフェーズは抽象化またはDSL自体の設計です。ここでは、LLMはコードジェネレーターよりもブレインストーミングパートナーとして扱うのが最善です。この記事の冒頭で論じたように、セマンティックモデルを構成する設計上の決定はすべて事前に仕様化することはできません。実装するにつれて、制約、トレードオフ、エッジケースを発見します。したがって、このフェーズは本質的に反復的でフィードバック駆動型です。構造を提案し、実際のケースに対して試行し、それがどこで厄介になるかを確認し、学んだことを次のラウンドにフィードバックします。LLMはそのループをスピードアップします — 代替案をスケッチし、設計を批判し、ある言語から別の言語にアイデアを移植しますが、あなたは完全にドライバーズシートに座っています。なぜなら、これらはあなたが理解し、所有する必要があるまさにその決定だからです。DSLを使いやすくする構造、たとえば不正なシナリオをコンパイル失敗させるプログレッシブインターフェースや、それを生成するビルダーから分離されたセマンティックモデルなどは、仕様を書いてコードを生成するのではなく、反復によって収束するものです。

2番目のフェーズは、抽象化またはDSLが配置された後に始まります。ここでLLMの行うことは変わります。それは、あなたが構築したものへの自然言語インターフェースになります。この記事のプロンプトはその例です — 「Tickloom Replicaとしてクォーラムストアを実装する」、「DDIA §10.6の読み取りを再現するシナリオを書く」、「このダイアグラムのスライドYAMLを作成する」。各ケースで、英語の説明はあなたが定義した語彙にほぼ直接マッピングされ、抽象化がプロンプトを接地するコンテキストと結果をチェックするハーネスの両方を提供するため、LLMは信頼できるジェネレーターです。

DSLを真実の情報源として

プロンプトを主要な真実の情報源として扱うという傾向が高まっています。よく設計されたDSLは、このダイナミクスを根本的に変えます。DSLと作業することの主な利点の1つは、生成されたプログラム自体が人間が保守する成果物になることが多いということです。DSLは密で表現力豊かで、付随的なボイラープレートがほとんどないため、生成後も読みやすい形式でソリューションの必須の意図を捉えます。LLMが自然言語リクエストからTickloom障害シナリオを生成した場合、結果のシナリオはすでにドメインの語彙で表現されています。来月シナリオを変更する必要がある場合、元のプロンプトを回復してすべてを再生成する必要はありません。DSLは、LLMが意図を理解し、それと連携するために十分なコンテキストを持っています。永続的な資産はプロンプトではなく、DSLとセマンティックモデルです。