Register a custom post type and its associated taxonomy in a theme's includes/ directory or a dedicated plugin. Covers labels, REST support, block template defaults, and the key-function pattern used across agency projects.

Step 0 — Understand the purpose

Ask the user: "What kind of content will this post type represent?" — a brief description of what it stores and where it will appear on the site.

Based on the description, suggest 2–3 slug options (lowercase with underscores), for example:

Based on your description, here are some suggestions:

# Slug Singular Plural
1 event Event Events
2 case_study Case Study Case Studies
3 project Project Projects

Which would you like to use, or do you have your own preference?

The user may pick one of the suggestions or provide their own.
Confirm the final choice before proceeding.

Step 1 — Gather remaining information

Input	Required	Notes
Post type slug	Yes	Lowercase with underscores, max 20 chars — e.g. `event`, `case_study`
Singular name	Yes	English, e.g. `Event`
Plural name	Yes	English, e.g. `Events`
Rewrite slug	Yes	URL slug, e.g. `events`
Location	Yes	Theme `includes/` or a plugin's `src/` / `inc/` — identify the exact package
Namespace	Yes	Check the surrounding package, e.g. `ProjectBase\Theme\PostTypes`
Needs taxonomy?	Yes	Should a category taxonomy be registered alongside this post type? (yes/no)
Taxonomy slug	If yes	e.g. `event_category`
Taxonomy singular name	If yes	English, e.g. `Category`
Taxonomy plural name	If yes	English, e.g. `Categories`
Taxonomy rewrite slug	If yes	URL slug, e.g. `event-categories`

Scan the target package for an existing post type file to confirm the namespace and file naming pattern used by the project.

Step 2 — Create the file

Theme: includes/post-type-{slug}.php
Plugin: inc/post-type-{slug}.php (or src/post-type-{slug}.php — match the project convention)

One file per post type, including its taxonomy registration.

Step 3 — Write the post type registration

<?php
/**
 * Post type: {Post Type Name}
 *
 * @package {PhpNamespace}
 */

declare( strict_types=1 );

namespace {PhpNamespace};

/**
 * Get the post type key.
 * Use this function everywhere instead of hardcoding the string.
 */
function get_{slug}_key(): string {
	return '{slug}';
}

/**
 * Register the post type.
 */
function register_{slug}(): void {
	$labels = [
		'name'               => _x( '{PluralName}', 'Post type general name', '{text-domain}' ),
		'singular_name'      => _x( '{SingularName}', 'Post type singular name', '{text-domain}' ),
		'add_new'            => __( 'Add new', '{text-domain}' ),
		'add_new_item'       => __( 'Add new {singularName}', '{text-domain}' ),
		'edit_item'          => __( 'Edit {singularName}', '{text-domain}' ),
		'new_item'           => __( 'New {singularName}', '{text-domain}' ),
		'view_item'          => __( 'View {singularName}', '{text-domain}' ),
		'view_items'         => __( 'View {pluralName}', '{text-domain}' ),
		'search_items'       => __( 'Search {pluralName}', '{text-domain}' ),
		'not_found'          => __( 'No {pluralName} found.', '{text-domain}' ),
		'not_found_in_trash' => __( 'No {pluralName} found in trash.', '{text-domain}' ),
		'all_items'          => __( 'All {pluralName}', '{text-domain}' ),
		'menu_name'          => __( '{PluralName}', '{text-domain}' ),
		'name_admin_bar'     => __( '{SingularName}', '{text-domain}' ),
	];

	\register_post_type(
		get_{slug}_key(),
		[
			'labels'       => $labels,
			'public'       => true,
			'show_in_rest' => true,
			'has_archive'  => true,
			'menu_icon'    => 'dashicons-admin-post',
			'rewrite'      => [
				'slug'       => '{rewrite-slug}',
				'with_front' => false,
			],
			'supports'     => [ 'title', 'editor', 'thumbnail', 'revisions', 'custom-fields' ],
			'taxonomies'   => [],
		]
	);
}
\add_action( 'init', __NAMESPACE__ . '\\register_{slug}' );

Choose an appropriate menu_icon dashicon for the content type.
Adjust supports based on what the post type needs (remove unused entries).
If a taxonomy is registered, add it to the 'taxonomies' array using get_{slug}_key() . '_category'.

Step 4 — Add the taxonomy (if needed)

Append to the same file, after the post type registration:

/**
 * Register the {slug} category taxonomy.
 */
function register_{slug}_category(): void {
	$labels = [
		'name'          => _x( '{TaxPluralName}', 'Taxonomy general name', '{text-domain}' ),
		'singular_name' => _x( '{TaxSingularName}', 'Taxonomy singular name', '{text-domain}' ),
		'search_items'  => __( 'Search {taxPluralName}', '{text-domain}' ),
		'all_items'     => __( 'All {taxPluralName}', '{text-domain}' ),
		'edit_item'     => __( 'Edit {taxSingularName}', '{text-domain}' ),
		'update_item'   => __( 'Update {taxSingularName}', '{text-domain}' ),
		'add_new_item'  => __( 'Add new {taxSingularName}', '{text-domain}' ),
		'new_item_name' => __( 'New {taxSingularName} name', '{text-domain}' ),
		'menu_name'     => __( '{TaxPluralName}', '{text-domain}' ),
	];

	\register_taxonomy(
		get_{slug}_key() . '_category',
		[ get_{slug}_key() ],
		[
			'labels'       => $labels,
			'hierarchical' => true,
			'show_in_rest' => true,
			'rewrite'      => [ 'slug' => '{tax-rewrite-slug}' ],
		]
	);
}
\add_action( 'init', __NAMESPACE__ . '\\register_{slug}_category' );

Step 5 — Verify auto-loading

Theme includes/: confirm functions.php loads files via glob (e.g. glob( __DIR__ . '/includes/*.php' )). If the glob is present, no manual require is needed.
Plugin: if the plugin does not use glob auto-loading, require the file explicitly from the plugin entry point.

Step 6 — Add a default block template (optional)

For post types that should open with a preset editor layout, add inside the register_{slug}() args array:

'template'      => [
    [ 'core/post-title' ],
    [ 'core/post-featured-image' ],
    [ 'core/post-content' ],
],
'template_lock' => false, // or 'all' to prevent changes

Step 7 — Lint

composer lint
composer lint-fix  # if needed
composer lint      # re-run to confirm clean

Conventions

Key function: always define get_{slug}_key(): string and use it everywhere — never hardcode the post type string in multiple places
show_in_rest: true: always — required for the block editor and REST API access
Labels: write all strings in English; use _x() for name and singular_name to provide translator context — translations are handled via .pot/.po files
Rewrite slug: use whatever URL slug makes sense for the project (can be English or localised)
Taxonomy coupling: always reference the post type via get_{slug}_key(), not the raw string
No hardcoded strings: post type and taxonomy keys must only appear in their respective get_*_key() functions
File naming: post-type-{slug}.php — one file per post type (including its taxonomy)

Output

A single post-type-{slug}.php file containing the post type and taxonomy registration, both hooked to init. The post type is visible in the WordPress admin, accessible via the REST API, and auto-loaded by the theme or plugin. Lint passes clean.

#	Slug	Singular	Plural
1	`event`	Event	Events
2	`case_study`	Case Study	Case Studies
3	`project`	Project	Projects