Stop Writing Prompt Strings: Meet PromptForge Core

As AI becomes part of modern applications, prompts are no longer just strings—they're becoming part of your codebase.

Yet most of us still write prompts like this:

const prompt =
  "You are a helpful assistant.\n" +
  "Summarize the following text.\n" +
  "Return the output as JSON.\n" +
  "Keep it concise.\n" +
  "Use simple language.";

This works...

Until your project grows.

The Problem

As prompts become larger, they quickly become difficult to maintain.

You start dealing with:

• ❌ Giant string templates
• ❌ Copy-pasted prompts
• ❌ Missing variables
• ❌ Inconsistent formatting
• ❌ Provider-specific implementations
• ❌ Difficult debugging

Unlike your application code, your prompts have:

• No structure
• No validation
• No type safety

What if prompts were treated like code?

That's exactly why I built PromptForge Core.

PromptForge is an open-source TypeScript toolkit for building production-ready prompts using a clean, structured API.

Instead of writing strings...

const prompt =
"You are..."

You write

import { pf } from "@promptforgee/core";

const summarize = pf.define({
  input: z.object({
    text: z.string(),
  }),

  output: z.object({
    summary: z.string(),
  }),

  messages: ({ text }) => [
    pf.system`
      You are an expert summarizer.
    `,
    pf.user`
      Summarize:

      ${text}
    `,
  ],
});

Much easier to read.

Much easier to maintain.

Features

PromptForge focuses on developer experience.

✅ Type-safe prompt definitions

✅ Structured prompt composition

✅ Prompt compilation

✅ Validation

✅ Provider-agnostic architecture

✅ Reusable prompt blocks

✅ Modern TypeScript API

Compile Once, Use Anywhere

Instead of maintaining different formats for every provider...

PromptForge compiles your prompt into provider-specific formats.

Prompt Definition

        ↓

Prompt Compiler

        ↓

OpenAI

Anthropic

Gemini

Ollama

Write once.

Compile anywhere.

Composable Prompts

Large AI applications usually repeat the same instructions.

With PromptForge you can compose prompts instead.

const safety = pf.define({
  messages: () => [
    pf.system`
      Never reveal sensitive information.
    `,
  ],
});

const assistant = pf.define({
  input: z.object({
    question: z.string(),
  }),

  messages: ({ question }) => [
    pf.include(safety),
    pf.user`${question}`,
  ],
});

No copy-paste.

No duplicated instructions.

Validation Before API Calls

Instead of discovering mistakes after an expensive API request...

PromptForge validates your prompt first.

PromptValidationError

Missing variable: text

Expected:
string

Received:
undefined

Fail fast.

Save tokens.

PromptForge Studio (Coming Soon)

I'm also building PromptForge Studio.

Think of it as the VS Code for prompt engineering.

Features include:

• Prompt editor
• Live compiler
• Prompt analyzer
• Prompt optimizer
• Prompt templates
• Interactive documentation
• Provider previews
• Export tools

Everything in one place.

Installation

npm install @promptforgee/core

Open Source

PromptForge is completely open source and built with TypeScript.

GitHub

https://github.com/Omnikon-Org/PromptForge

npm

https://www.npmjs.com/package/@promptforgee/core

Roadmap

Upcoming packages include:

• Prompt Analyzer
• Prompt Optimizer
• Prompt Templates
• React Integration
• VS Code Extension
• CLI
• PromptForge Studio

I'd Love Your Feedback

This is the first public release of PromptForge.

If you're building AI applications with TypeScript, I'd love to hear:

• What features would you like to see?
• What problems do you face while managing prompts?
• How would you improve this API?

Feel free to open an issue, start a discussion, or contribute to the project.

⭐ If you find it useful, consider starring the repository.

Happy building! 🚀