GitHub Actions
is the 9th most disliked
developer tool

Pragmatic Engineer State of DevTools 2025

Stop configuring CI/CD.
Start programming it.

Repository configuration: typed, versioned, shared

Typeflows brings Configuration-as-Code to GitHub Actions

Type-safety & Refactoring support

YAML import/export

Workflow orchestration testing

Workflow visualisations

Package Modularity

See Typeflows in Action

Stop Me If You've Heard This One...

(We've all been there)

Manual CI updates everywhere

GitHub's reusable workflows help, but managing versions across 50 repos is still manual. No automatic dependency management, no testing.

With Typeflows:

Manage workflows like real packages with automated updates, dependency resolution, and test before you commit.

Complex expressions in YAML

GitHub Actions expressions are painful. One typo breaks everything and the templating language is impossible to debug.

With Typeflows:

Express complex logic in real code with proper conditionals and type checking.

Workflow chaos cascade

Change one workflow trigger and three others break mysteriously. Jobs run on wrong branches with no way to test coordination logic locally.

With Typeflows:

Test workflow coordination logic locally - validate which jobs run when, without pushing commits.

Fragile inputs and outputs

Good luck remembering parameter names for marketplace actions. Hope you typed the output name correctly. Every integration feels like trial and error.

With Typeflows:

Type-safe marketplace actions with IDE autocomplete for all parameters and outputs.

Hidden GitHub limits

You build sophisticated reusable workflows, then GitHub mysteriously rejects your YAML with "workflow nesting too deep". Invisible composition limits break without warning.

With Typeflows:

No artificial limits - complex workflow composition flattens into deployable YAML automatically.

From Code to YAML (and back again!)

Real code. Real testing. Real confidence.

Better Experience in Landscape Mode

The code examples look much better when viewed horizontally. Please rotate your device for the best experience!

Or view on a larger screen to see the code!

Typeflows DSL

class Deploy : Builder<Workflow> {
	override fun build() = Workflow("deploy") {
		on += Push {
			branches = Branches.Only("main")
			paths = Paths.Only("src/**")
		}

		val buildJob = Job("build", UBUNTU_LATEST) {
			steps += Checkout()

			steps += UseAction("actions/setup-node@v4") {
				with["node-version"] = "20"
			}

			steps += RunCommand("npm run build && npm test")
		}

		jobs += buildJob

		jobs += Job("deploy", UBUNTU_LATEST) {
			needs += buildJob

			steps += UseAction("actions/deploy@v2") {
				with["target"] = "production"
				with["token"] = $$"${{ secrets.DEPLOY_TOKEN }}"
			}
		}
	}
}

public class Deploy implements Builder<Workflow> {

	@NotNull
	@Override
	public Workflow build() {
		return Workflow.create("deploy-to-prod", workflow -> {
			workflow.displayName = "Deploy to Production";
			workflow.on.add(Push.create(push -> {
				push.branches = Branches.Only("main");
				push.paths = Paths.Only("src/**");
			}));

			Job buildJob = Job.create("build", UBUNTU_LATEST, job -> {
				job.steps.add(Checkout.create());

				job.steps.add(UseAction.create(
					"actions/setup-node@v4", action -> {
					    action.name = "node";
					    action.with.put("node-version", "20");
					}
				));

				job.steps.add(
					RunCommand.create("npm run build && npm test")
				);
			});

			workflow.jobs.add(buildJob);

			workflow.jobs.add(Job.create("deploy", UBUNTU_LATEST, job -> {
				job.needs.add(buildJob);
				job.steps.add(
					UseAction.create("actions/deploy@v2", action -> {
					    action.name = "deploy";
					    action.with.put("target", "production");
					    action.with.put("token", "${{ secrets.DEPLOY_TOKEN }}");
					}));
			}));
		});
	}
}

export class Deploy implements Builder<Workflow> {
	build(): Workflow {
		return Workflow.create("Deploy to Production", workflow => {
			workflow.on.add(Push.create(push => {
				push.branches = Branches.only("main");
				push.paths = Paths.only("src/**");
			}));

			const buildJob = Job.create("build", UBUNTU_LATEST, job => {
				job.steps.add(checkout());
				job.steps.add(
					UseAction.create("actions/setup-node@v4", "node", action =>
					    action.with["node-version"] = "20"
					)
				);
				job.steps.add(RunCommand.create("npm run build && npm test"));
			});

			workflow.jobs.add(buildJob);

			workflow.jobs.add(Job.create("deploy", UBUNTU_LATEST, job => {
				job.needs.add(buildJob);
				job.steps.add(
					UseAction.create("actions/deploy@v2", "deploy", action => {
					    action.with["target"] = "production";
					    action.with["token"] = "${{ secrets.DEPLOY_TOKEN }}";
					})
				);
			}));
		});
	}
}

class Deploy(Builder[Workflow]):
	def build(self) -> Workflow:
		with Workflow.create("Deploy to Production") as workflow:
			with Push.create() as push:
				push.branches = Branches.only("main")
				push.paths = Paths.only("src/**")

			workflow.on.add(push)

			with Job.create("build", UBUNTU_LATEST) as build_job:
				build_job.steps.add(checkout())

				with UseAction.create("actions/setup-node@v4") as action:
					action.with_["node-version"] = "20"

				build_job.steps.add(action)
				build_job.steps.add(
					RunCommand.create("npm run build && npm test")
				)

			workflow.jobs.add(build_job)

			with Job.create("deploy", UBUNTU_LATEST) as deploy_job:
				deploy_job.needs.add(build_job)

				with UseAction.create("actions/deploy@v2") as action:
					action.with_["target"] = "production"
					action.with_["token"] = "${{ secrets.DEPLOY_TOKEN }}"

				deploy_job.steps.add(action)

			workflow.jobs.add(deploy_job)

		return workflow

Generated YAML

name: Deploy to Production

on:
  push:
	branches: [main]
	paths: ['../../../..']

jobs:
  build:
	runs-on: ubuntu-22.04
	steps:
	  - uses: actions/checkout@v4
	  - uses: actions/setup-node@v4
		with:
		  node-version: '20'
	  - name: Build and Test
		run: npm run build && npm test

  deploy:
	needs: [build]
	runs-on: ubuntu-latest
	environment: production
	steps:
	  - uses: actions/deploy@v2
		with:
		  target: production
		  token: ${{ secrets.DEPLOY_TOKEN }}

Powerful Features for Everyone

Type-safe workflows and beyond - manage your entire GitHub configuration with the same powerful features

Stop debugging YAML in the browser

Your IDE catches workflow errors before you commit. YAML's lack of compile-time validation means syntax errors only surface at runtime - your development environment prevents this.

Compose your .github/ from versioned components

Build your entire GitHub configuration from reusable, versioned components. Workflows, CODEOWNERS, AI assistant instructions, security policies, and issue templates with dependency management and semantic versioning across teams.

Validate workflow orchestration

Test which jobs run when, validate trigger conditions, and verify job dependencies work correctly. Test workflow coordination logic locally. No more "push and pray" debugging.

AI-powered developer experience

Copilot learns your team's coding standards automatically. AI assistant instructions, TDD practices, architecture patterns, and code conventions stay consistent across your entire development workflow and CI/CD pipeline.

Migrate gradually

Import your existing workflows automatically. Convert one at a time. Keep shipping while you improve your developer experience.

Zero lock-in

Export standard GitHub Actions YAML anytime. No proprietary formats. Your workflows remain portable and future-proof.

Repository Visualisation

Auto-generated diagrams and documentation that keep your team aligned and your workflows transparent.

Workflow Diagrams

Visualize job dependencies and execution flow

Job Dependencies

Clear visualisation of which jobs depend on others

Step Breakdown

Detailed view of every action and step in each job

Trigger Conditions

See exactly when and why workflows execute

Data Flow

Track artifacts and outputs between jobs

Coming soon: Copilot instructions, security policies, branch protection, and full .github folder visualisation

ROADMAP

Manual YAML vs Typeflows

See Configuration-as-Code in action

Challenge	Manual YAML	Typeflows
Syntax errors	Runtime failures	Compile-time validation
Testing	Push and pray	Test workflow orchestration locally
IDE support	Basic syntax highlighting/formatting	Full autocomplete & refactoring
Workflow reuse	Copy-paste duplication	Import workflows/actions as packages
Composition limits	Mysterious workflow/job limit errors	No artificial limits
Refactoring	Find/replace across files	Safe automated updates
Documentation	Manual docs that get stale	Auto-generated visualisations

Syntax errors

Manual YAML: Runtime failures

Typeflows: Compile-time validation

Testing

Manual YAML: Push and pray

Typeflows: Test workflow orchestration locally

IDE support

Manual YAML: Basic syntax highlighting/formatting

Typeflows: Full autocomplete & refactoring

Workflow reuse

Manual YAML: Copy-paste duplication

Typeflows: Import workflows/actions as packages

Your GitHub configuration is
out of control

Repository configuration: typed, versioned, shared

Transform your entire .github/ folder into type-safe, testable, shareable code

The hidden cost of
configuration drift

Every repository starts by copying .github/ from another project. They immediately diverge, creating maintenance headaches.

Original .github/

✅ workflows/

✅ dependabot.yml

✅ CODEOWNERS

✅ copilot-instructions.md

Copy & Paste across org

Repo A

❌ missing files

⚠️ old versions

Repo B

⚠️ different config

🔓 security gaps

Repo C

⚠️ outdated policies

💥 broken workflows

Original .github/

Clean, organised, secure

Copy & paste across organisation

Repo A

Missing files

Repo B

Security gaps

Repo C

Broken workflows

Configuration drift

Every repo starts by copying .github/ from another. They immediately diverge and become inconsistent across your organisation.

Outdated policies

Security configs, Dependabot settings, and CODEOWNERS drift apart. Compliance becomes impossible to track and enforce.

No versioning

Updating policies means manually editing hundreds of repos. No rollback, no testing, no audit trail.

Build your .github/ from composable parts

Typeflows brings Configuration-as-Code to repository management. Compose your entire .github/ folder from type-safe, reusable components.

Better Experience in Landscape Mode

The code examples look much better when viewed horizontally. Please rotate your device for the best experience!

Or view on a larger screen to see the code!

Reusable Components

Build each .github/ file type as a separate, testable component with proper type-safety and IDE support. Write once, reuse everywhere.

class CI : Builder<Workflow> {

	override fun build() = Workflow("build") {
		on += WorkflowDispatch.create()

		permissions = Permissions(Contents to Write)

		on += Push {
			branches = Branches.Main
			paths = Paths.Ignore("**/.md")
		}

		on += PullRequest {
			paths = Paths.Ignore("**/.md")
		}

		jobs += Job("build", UBUNTU_LATEST) {
			steps += Checkout()

			steps += SetupJava(Adopt, V21)

			steps += SetupGradle()

			steps += RunCommand("./gradlew check")

			steps += UseAction(
				"mikepenz/action-junit-report@v5.6.2"
			) {
				condition = always()
				with["report_paths"] = "**/TEST-*.xml"
				with["github_token"] = GITHUB_TOKEN
			}
		}
	}
}

class StandardDependabot : Builder<Dependabot> {

	override fun build() = Dependabot {
		updates += Update(Gradle) {
			directory = "/"
			schedule =
				DepdendabotSchedule(Daily) {
					time = LocalTime.of(9, 0)
					timezone = ZoneId.of("UTC")
				}
			openPullRequestsLimit = 5
		}

		updates += Update(GitHubActions) {
			directory = "/.github"
			schedule =
				DepdendabotSchedule(Weekly) {
					time = LocalTime.of(12, 0)
					day = MONDAY
				}
			openPullRequestsLimit = 5
		}
	}
}

class Microservice() : Builder<MarkdownContent> {
	override fun build() =
		MarkdownContent.fromResource(Microservice::class.java, "hexagonal-architecture.md") +
			MarkdownContent.fromResource(Microservice::class.java, "tdd.md") +
			MarkdownContent.fromResource(Microservice::class.java, "12-factor.md")
}

class TeamCodeOwners(private val team: String) : Builder<CodeOwners> {

	override fun build() = CodeOwners {
		owners["*"] = "@${team}-platform"

		owners["src/web/**"] = "@${team}-frontend"

		owners["src/api/**"] = "@${team}-backend @${team}-platform"

		owners[".github/workflows/**"] = "@${team}-security"

		owners["Dockerfile*"] = "@${team}-security"

		owners["*.security.yml"] = "@${team}-security"

		owners["migrations/**"] = "@${team}-backend @${team}-dba"

		owners["*.sql"] = "@${team}-backend @${team}-dba"
	}
}

public class CI implements Builder<Workflow> {

	@NotNull
	@Override
	public Workflow build() {
		return Workflow.create("build", wf -> {
			wf.displayName = "Build";
			wf.on.add(WorkflowDispatch.create());

			wf.permissions = Permissions.create(
				new HashMap<>() {{
					put(Contents, Write);
				}}
			);

			wf.on.add(Push.create(push -> {
				push.branches = Branches.Main;
				push.paths = Paths.Ignore("**/.md");
			}));

			wf.on.add(PullRequest.create(pr -> {
				pr.paths = Paths.Ignore("**/.md");
			}));

			wf.jobs.add(Job.create("build",
				UBUNTU_LATEST, job -> {
					job.steps.add(Checkout.create());

					job.steps.add(
					    SetupJava.create(Adopt, V21)
					);

					job.steps.add(SetupGradle.create());

					job.steps.add(
					    RunCommand.create("./gradlew check")
					);

					job.steps.add(UseAction.create(
					    "mikepenz/action-junit-report@v5.6.2", action -> {
					        action.condition = always();
					        action.with.put("report_paths", "**/TEST-*.xml");
					        action.with.put("github_token", GITHUB_TOKEN);
					    }
					));
				}));
		});
	}
}

public class StandardDependabot implements Builder<Dependabot> {

	@Override
	public Dependabot build() {
		return Dependabot.create(dsl -> {
			dsl.updates.add(Update.create(Maven, update -> {
				update.directory = "/";
				update.schedule = DepdendabotSchedule.create(Daily, schedule -> {
					schedule.time = LocalTime.of(9, 0);
					schedule.timezone = ZoneId.of("UTC");
				});
				update.openPullRequestsLimit = 5;
			}));

			dsl.updates.add(Update.create(GitHubActions, update -> {
				update.directory = "/";
				update.schedule = DepdendabotSchedule.create(Weekly, schedule -> {
					schedule.time = LocalTime.of(12, 0);
					schedule.day = MONDAY;
				});
				update.openPullRequestsLimit = 5;
			}));
		});
	}
}

public class Microservice implements Builder<MarkdownContent> {

	@Override
	public MarkdownContent build() {
		return markdownMd("hexagonal-architecture.md")
			.plus(markdownMd("tdd.md"))
			.plus(markdownMd("12-factor.md"));
	}

	@NotNull
	private static MarkdownContent markdownMd(String resourceName) {
		return fromResource(Microservice.class, resourceName);
	}
}

public class TeamCodeOwners implements Builder<CodeOwners> {

	private final String team;

	public TeamCodeOwners(String team) {
		this.team = team;
	}

	@Override
	public CodeOwners build() {
		return CodeOwners.create(dsl -> {
			dsl.owners.put("*", "@" + team + "-platform");

			dsl.owners.put("src/web/**", "@" + team + "-frontend");

			dsl.owners.put("src/api/**", "@" + team + "-backend @" + team + "-platform");

			dsl.owners.put(".github/workflows/**", "@" + team + "-security");

			dsl.owners.put("Dockerfile*", "@" + team + "-security");

			dsl.owners.put("*.security.yml", "@" + team + "-security");

			dsl.owners.put("migrations/**", "@" + team + "-backend @" + team + "-dba");

			dsl.owners.put("*.sql", "@" + team + "-backend @" + team + "-dba");
		});
	}
}

export class CI implements Builder<Workflow> {
	build(): Workflow {
		return Workflow.create("Build", workflow => {
			workflow.on.add(WorkflowDispatch.create());

			workflow.permissions = Permissions.create({
				[Contents]: Write
			});

			workflow.on.add(Push.create(push => {
				push.branches = Branches.Main;
				push.paths = Paths.ignore("**/.md");
			}));

			workflow.on.add(PullRequest.create(pr => {
				pr.paths = Paths.ignore("**/.md");
			}));

			workflow.jobs.add(
				Job.create("build", UBUNTU_LATEST, job => {
					job.steps.add(Checkout.create());

					job.steps.add(SetupJava.create(Adopt, V21));

					job.steps.add(SetupGradle.create());

					job.steps.add(RunCommand.create("./gradlew check"));

					job.steps.add(
					    UseAction.create(
					        "mikepenz/action-junit-report@v5.6.2",
					        a => {
					            a.condition = "always()";
					            a.with["report_paths"] = "**/*.xml";
					            a.with["github_token"] = GITHUB_TOKEN;
					        })
					);
				}));
		});
	}
}

export class StandardDependabot implements Builder<Dependabot> {

	build(): Dependabot {
		return new Dependabot(dsl => {
			dsl.updates.add(new Update(PackageEcosystem.NPM, updateDsl => {
				updateDsl.directory = "/"
				updateDsl.schedule = new DepdendabotSchedule(Daily, scheduleDsl => {
					scheduleDsl.time = "09:00"
					scheduleDsl.timezone = "UTC"
				})
				updateDsl.openPullRequestsLimit = 5
			}))

			dsl.updates.add(new Update(PackageEcosystem.GitHubActions, updateDsl => {
				updateDsl.directory = "/.github"
				updateDsl.schedule = new DepdendabotSchedule(Weekly, scheduleDsl => {
					scheduleDsl.time = "12:00"
					scheduleDsl.day = "monday"
				})
				updateDsl.openPullRequestsLimit = 5
			}))
		})
	}
}

export class Microservice implements Builder<MarkdownContent> {

	build(): MarkdownContent {
		return MarkdownContent.fromResource("hexagonal-architecture.md")
			.plus(MarkdownContent.fromResource("tdd.md"))
			.plus(MarkdownContent.fromResource("12-factor.md"))
	}
}

export class TeamCodeOwners implements Builder<CodeOwners> {

	constructor(private team: string) {
	}

	build(): CodeOwners {
		return new CodeOwners(dsl => {
			dsl.owners["*"] = `@${this.team}-platform`

			dsl.owners["src/web/**"] = `@${this.team}-frontend`

			dsl.owners["src/api/**"] = `@${this.team}-backend @${this.team}-platform`

			dsl.owners[".github/workflows/**"] = `@${this.team}-security`

			dsl.owners["Dockerfile*"] = `@${this.team}-security`

			dsl.owners["*.security.yml"] = `@${this.team}-security`

			dsl.owners["migrations/**"] = `@${this.team}-backend @${this.team}-dba`

			dsl.owners["*.sql"] = `@${this.team}-backend @${this.team}-dba`
		})
	}
}

class CI(Builder[Workflow]):
	def build(self) -> Workflow:
		with Workflow.create("Build") as workflow:
			workflow.on.add(WorkflowDispatch.create())

			workflow.permissions = Permissions.create({
				Contents: Write
			})

			with Push.create() as push:
				push.branches = Branches.Main
				push.paths = Paths.ignore("**/.md")

			workflow.on.add(push)

			with PullRequest.create() as pr:
				pr.paths = Paths.ignore("**/.md")

			workflow.on.add(pr)

			with Job.create("build", UBUNTU_LATEST) as job:
				job.steps.add(Checkout.create())

				job.steps.add(SetupJava.create(Adopt, V21))

				job.steps.add(SetupGradle.create())

				job.steps.add(RunCommand.create("./gradlew check"))

				with UseAction.create(
					"mikepenz/action-junit-report@v5.6.2"
				) as action:
					action.condition = "always()"
					action.with_["report_paths"] = "**/TEST-*.xml"
					action.with_["github_token"] = GITHUB_TOKEN

				job.steps.add(action)

			workflow.jobs.add(job)

		return workflow

class StandardDependabot(Builder[Dependabot]):

	def build(self) -> Dependabot:
		with Dependabot() as dsl:
			with Update(PackageEcosystem.PIP) as update:
				update.directory = "/"
				with DepdendabotSchedule(DAILY) as schedule:
					schedule.time = time(9, 0)
					schedule.timezone = "UTC"
				update.schedule = schedule
				update.open_pull_requests_limit = 5
			dsl.updates.append(update)

			with Update(PackageEcosystem.GITHUB_ACTIONS) as update:
				update.directory = "/.github"
				with DepdendabotSchedule(WEEKLY) as schedule:
					schedule.time = time(12, 0)
					schedule.day = "monday"
				update.schedule = schedule
				update.open_pull_requests_limit = 5
			dsl.updates.append(update)

		return dsl

class Microservice(Builder[MarkdownContent]):
	def build(self) -> MarkdownContent:
		return (MarkdownContent.from_resource("hexagonal-architecture.md") +
				MarkdownContent.from_resource("tdd.md") +
				MarkdownContent.from_resource("12-factor.md"))

class TeamCodeOwners(Builder[CodeOwners]):
	
	def __init__(self, team: str):
		self.team = team
	
	def build(self) -> CodeOwners:
		with CodeOwners() as dsl:
			dsl.owners["*"] = f"@{self.team}-platform"
			dsl.owners["src/web/**"] = f"@{self.team}-frontend"
			dsl.owners["src/api/**"] = f"@{self.team}-backend @{self.team}-platform"
			dsl.owners[".github/workflows/**"] = f"@{self.team}-security"
			dsl.owners["Dockerfile*"] = f"@{self.team}-security"
			dsl.owners["*.security.yml"] = f"@{self.team}-security"
			dsl.owners["migrations/**"] = f"@{self.team}-backend @{self.team}-dba"
			dsl.owners["*.sql"] = f"@{self.team}-backend @{self.team}-dba"
		
		return dsl

Complete .github/ Configuration

Compose all components into a single DotGitHub class that manages your entire .github/ folder. One class, complete control.

class Typeflows : Builder<TypeflowsGitHubRepo> {

	override fun build() = TypeflowsGitHubRepo {

		dotGithub = DotGitHub {
			workflows += CI()
			workflows += Deploy()

			files += StandardDependabot()

			files += StandardSecretScanning()

			files += TeamCodeOwners("myteam")

			files += CopilotInstructions {
				content +=
					markdownMd("hexagonal-architecture.md") +
					    markdownMd("tdd.md") +
					    markdownMd("kotlin-style.md")

				content += Microservice()
			}
		}
	}

	private fun markdownMd(resourceName: String) =
		fromResource(Microservice::class.java, resourceName)
}

public class Typeflows implements Builder<TypeflowsGitHubRepo> {

	@Override
	public TypeflowsGitHubRepo build() {
		return TypeflowsGitHubRepo.create(repo ->

			repo.dotGithub = DotGitHub.create(dsl -> {
				dsl.workflows.add(new CI());
				dsl.workflows.add(new Deploy());

				dsl.files.add(new StandardDependabot());

				dsl.files.add(new StandardSecretScanning());

				dsl.files.add(new TeamCodeOwners("myteam"));

				dsl.files.add(CopilotInstructions.create(copilot ->
					copilot.content = copilot.content
					    .plus(markdownMd("java-style.md"))
					    .plus(new Microservice()))
				);
			})
		);
	}

	@NotNull
	private static MarkdownContent markdownMd(String resourceName) {
		return fromResource(Typeflows.class, resourceName);
	}
}

export class TypeflowsRepo implements Builder<TypeflowsRepo> {

	build(): TypeflowsRepo {

		return TypeflowsGitHubRepo.create(dsl => {

			dsl.dotGitHub = DotGitHub.create(gh => {
				gh.workflows.add(new CI())
				gh.workflows.add(new Deploy())

				gh.files.add(new StandardDependabot())

				gh.files.add(new StandardSecretScanning())

				gh.files.add(new TeamCodeOwners("myteam"))

				gh.files.add(CopilotInstructions.create(copilot => {
					copilot.content = copilot.content
					    .plus(MarkdownContent.fromResource("typescript-style.md"))
					    .plus(new Microservice())
				}))
			})

		})
	}
}

class TypeflowsRepo(Builder[TypeflowsGitHubRepo]):

	def build(self) -> TypeflowsGitHubRepo:

		with TypeflowsGitHubRepo() as repo:

			with DotGitHub() as dsl:
				dsl.workflows.append(CI())
				dsl.workflows.append(Deploy())

				dsl.files.append(StandardDependabot())

				dsl.files.append(StandardSecretScanning())
				dsl.files.append(TeamCodeOwners("myteam"))

				with CopilotInstructions() as copilot:
					copilot.content = copilot.content.plus(
					    MarkdownContent.from_resource("python-style.md")
					).plus(
					    Microservice()
					)
				dsl.files.append(copilot)
			repo.dotGitHub = dsl

		return repo

Test Everything

Unit test workflows, security policies, and team configurations before deploying.

Version Control

Track changes, rollback updates, and maintain audit trails for compliance.

Share & Reuse

Package and distribute your standards across teams and organisations.

Package and distribute
your standards

Version and share your configurations like any other software dependency.

Better Experience in Landscape Mode

The code examples look much better when viewed horizontally. Please rotate your device for the best experience!

Or view on a larger screen to see the code!

Publish package

Configure your build to publish standards as versioned packages.

plugins {
	kotlin("jvm")
	`maven-publish`
}

dependencies {
	api("io.typeflows:typeflows-github")
}

publishing {
	publications {
		create<MavenPublication>("maven") {
			groupId = "com.company"
			artifactId = "github-standards"
			version = "2.1.0"

			from(components["java"])

			pom {
				name.set("Company GitHub Standards")
				description.set("Reusable GitHub configurations and policies")
			}
		}
	}

	repositories {
		maven {
			url = uri("https://packages.company.com/maven")
			credentials {
				username = System.getenv("MAVEN_USERNAME")
				password = System.getenv("MAVEN_PASSWORD")
			}
		}
	}
}

{
	"name": "@company/github-standards",
	"version": "2.1.0",
	"description": "Reusable GitHub configurations and policies",
	"main": "dist/index.js",
	"types": "dist/index.d.ts",
	"publishConfig": {
		"registry": "https://npm.company.com/"
	},
	"repository": {
		"type": "git",
		"url": "https://github.com/company/github-standards"
	},
	"files": [
		"dist/",
		"README.md"
	],
	"scripts": {
		"build": "tsc",
		"publish": "npm run build && npm publish"
	},
	"devDependencies": {
		"@typeflows/core": "^1.0.0",
		"typescript": "^5.0.0"
	}
}

name = "company-github-standards"
version = "2.1.0"
description = "Reusable GitHub configurations and policies"
authors = [
	{name = "Platform Team", email = "platform@company.com"}
]
dependencies = [
	"typeflows-core>=1.0.0"
]
requires-python = ">=3.8"

[project.urls]
Repository = "https://github.com/company/github-standards"
Documentation = "https://docs.company.com/github-standards"

[tool.setuptools.packages.find]
where = ["src"]

[tool.setuptools.package-data]
"*" = ["*.md", "*.yaml", "*.yml"]

Teams consume

Teams add your standards as dependencies and control upgrades.

plugins {
	kotlin("jvm")
	id("io.typeflows")
}

repositories {
	mavenCentral()
	maven("https://packages.company.com/maven")
}

dependencies {
	implementation("com.company:github-standards:2.1.0")
	implementation("io.typeflows:typeflows-github")
}

typeflows {
	typeflowsClass = "TypeflowsRepo"
}

<project xmlns="http://maven.apache.org/POM/4.0.0">
	<dependencies>
		<dependency>
			<groupId>io.typeflows</groupId>
			<artifactId>typeflows-github</artifactId>
			<version>1.0.0</version>
		</dependency>
	</dependencies>
	
	<build>
		<plugins>
			<plugin>
				<groupId>io.typeflows</groupId>
				<artifactId>typeflows-maven-plugin</artifactId>
				<version>1.0.0</version>
				<configuration>
					<typeflowsClass>com.example.docs.how_to.composing_llm_agent_instructions.Typeflows</typeflowsClass>
				</configuration>
				<executions>
					<execution>
					    <goals>
					        <goal>export</goal>
					    </goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

{
  "name": "team-repo",
  "version": "1.0.0",
  "private": true,
  "dependencies": {
	"@company/github-standards": "^2.1.0",
	"@typeflows/typeflows": "^1.0.0"
  },
  "scripts": {
	"generate-github": "typeflows generate",
  },
  "typeflows": {
	  "typeflows": "@company/github-standards/TypeflowsRepo"
	}
  }
}

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "team-repo"
version = "1.0.0"

dependencies = [
	"company-github-standards==2.1.0",
	"typeflows>=1.0.0"
]

[tool.typeflows]
typeflows = "src/docs.how_to.composing_llm_agent_instructions.Typeflows.py"

Works with all major package registries

Maven Central

npm

PyPI

GitHub Packages

Artifactory

Nexus

Start small,
scale gradually

No need to replace everything at once. Upgrade your GitHub configuration management incrementally with zero lock-in.

Import existing

Convert your current YAML workflows and configurations into type-safe code. Keep everything working exactly as before.

Prove with one team

Start with a single repository or team. Demonstrate the value of type-safe configurations, testing, and code reuse.

Expand gradually

Roll out across your organisation at your own pace. Share standards packages and maintain consistency at scale.

Zero lock-in - Everything compiles to standard YAML

Your timeline - Migrate at your own pace

Immediate value - Benefits from day one

Platform capabilities
for modern teams

Complete GitHub configuration management at scale. From workflows to security policies, manage everything as versioned, testable code.

Composable configuration packages

Build GitHub standards from modular, reusable components. Mix organisational policies with team customisations. Share battle-tested patterns as versioned libraries, not brittle copy-paste templates.

Configuration inheritance and overrides

Define organisational base configurations that teams extend and customise. Enforce non-negotiable security requirements while enabling team-specific workflows and policies.

Dependency management for GitHub configs

Upgrade GitHub configurations like software dependencies. Semantic versioning, compatibility matrices, and controlled rollouts across hundreds of repositories with proper dependency resolution.

Workflow orchestration testing

Test which jobs run under what conditions before pushing. Validate trigger logic, verify job dependencies, and simulate complex multi-workflow coordination scenarios locally.

Repository Visualisation

Auto-generated diagrams and documentation that help teams understand and manage complex repository configurations.

Workflow Visualisation

Visualise complex workflow dependencies and execution flow

Complex Dependencies

Visualise intricate job dependencies and conditional flows

Detailed Breakdown

Every action, step, and condition in multi-stage workflows

Advanced Triggers

Complex trigger conditions and workflow orchestration

Multi-Stage Flow

Track data and artifacts through complex pipelines

Visualisation Roadmap

Expanding visualisation to cover complete .github folder management

copilot-instructions.md Security Policies Branch Protection CODEOWNERS

Frequently Asked Questions

Common questions about Typeflows and workflow development Common questions about Typeflows and GitHub configuration management

GitHub Actionsis the 9th most dislikeddeveloper tool

Stop configuring CI/CD.Start programming it.

Repository configuration: typed, versioned, shared

Stop Me If You've Heard This One...

Manual CI updates everywhere

Complex expressions in YAML

Workflow chaos cascade

Fragile inputs and outputs

Hidden GitHub limits

From Code to YAML (and back again!)

Better Experience in Landscape Mode

Typeflows DSL

Generated YAML

Powerful Features for Everyone

Stop debugging YAML in the browser

Compose your .github/ from versioned components

Validate workflow orchestration

AI-powered developer experience

Migrate gradually

Zero lock-in

Repository Visualisation

Workflow Diagrams

Job Dependencies

Step Breakdown

Trigger Conditions

Data Flow

Manual YAML vs Typeflows

Syntax errors

Testing

IDE support

Workflow reuse

Your GitHub configuration isout of control

Repository configuration: typed, versioned, shared

Transform your entire .github/ folder into type-safe, testable, shareable code

The hidden cost ofconfiguration drift

Original .github/

Repo A

Repo B

Repo C

Original .github/

Configuration drift

Outdated policies

No versioning

Build your .github/ from composable parts

Better Experience in Landscape Mode

Reusable Components

Complete .github/ Configuration

Test Everything

Version Control

Share & Reuse

Package and distributeyour standards

Better Experience in Landscape Mode

Publish package

Teams consume

Start small,scale gradually

Import existing

Prove with one team

Expand gradually

Platform capabilitiesfor modern teams

Composable configuration packages

Configuration inheritance and overrides

Dependency management for GitHub configs

Workflow orchestration testing

Repository Visualisation

Workflow Visualisation

Complex Dependencies

Detailed Breakdown

Advanced Triggers

Multi-Stage Flow

Visualisation Roadmap

Ready to stop debugging YAML? revolutionise your GitHub management?

Frequently Asked Questions

What form does Typeflows take? Is it a SaaS?

How much does Typeflows cost?

How hard is it to migrate my existing workflows?

How does workflow testing work?

Will this work with my existing GitHub Actions setup?

How does this differ from reusable workflows?

Can I manage my entire organisation's GitHub configuration?

What about compliance and security policies?

GitHub Actions
is the 9th most disliked
developer tool

Stop configuring CI/CD.
Start programming it.

Your GitHub configuration is
out of control

The hidden cost of
configuration drift

Package and distribute
your standards

Start small,
scale gradually

Platform capabilities
for modern teams