Most developers learn WordPress theme development the hard way. You download a bloated starter theme or inspect a commercial multi-purpose theme packed with thirty thousand lines of framework code, four page builders, and eighty theme options. You get lost in hundreds of abstraction files before writing a single line of HTML.
You do not need a massive framework to build a custom WordPress theme.
At its core, a WordPress theme is simply a collection of PHP templates, stylesheets, and assets that take structured content from a MySQL database and render it as clean, semantic HTML in a browser. You can build a fully functional, production-ready custom theme with as few as two files.
Whether you want to build bespoke client websites from scratch or understand what happens behind the scenes of an existing site, this roadmap breaks down the core architecture of custom theme development without the fluff.
1. The Minimum Anatomy: Two Essential Files
Every WordPress theme lives inside its own folder in wp-content/themes/.
To turn a standard folder into an active WordPress theme recognized by the admin dashboard, you only need two files:
style.css: The primary stylesheet that also contains the theme metadata header.index.php: The fallback template file that renders page content.
The style.css Header
WordPress reads the comment block at the very top of style.css to identify the theme name, author, version, and licensing. Without this header, WordPress ignores the folder entirely.
Create a folder named my-custom-theme inside wp-content/themes/ and add style.css:
/*
Theme Name: My Custom Theme
Theme URI: https://example.com/my-custom-theme
Author: Jane Developer
Author URI: https://example.com
Description: A lightweight, custom WordPress theme built from scratch.
Version: 1.0.0
Requires at least: 6.0
Tested up to: 6.7
Requires PHP: 7.4
License: GNU General Public License v2 or later
License URI: http://www.gnu.org/licenses/gpl-2.0.html
Text Domain: my-custom-theme
*/
/* Custom CSS begins below */
body {
margin: 0;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
color: #1a202c;
background-color: #f7fafc;
line-height: 1.6;
}
The Fallback index.php
The index.php file is the master fallback template in WordPress. If WordPress cannot find a more specific template (like single.php for blog posts or page.php for static pages), it uses index.php.
<!DOCTYPE html>
<html <?php language_attributes(); ?>>
<head>
<meta charset="<?php bloginfo('charset'); ?>">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<?php wp_head(); ?>
</head>
<body <?php body_class(); ?>>
<?php wp_body_open(); ?>
<header class="site-header">
<div class="container">
<h1><a href="<?php echo esc_url(home_url('/')); ?>"><?php bloginfo('name'); ?></a></h1>
<p><?php bloginfo('description'); ?></p>
</div>
</header>
<main class="site-main container">
<?php
if (have_posts()) :
while (have_posts()) : the_post();
?>
<article id="post-<?php the_ID(); ?>" <?php post_class(); ?>>
<h2><a href="<?php the_permalink(); ?>"><?php the_title(); ?></a></h2>
<div class="entry-content">
<?php the_excerpt(); ?>
</div>
</article>
<?php
endwhile;
else :
?>
<p><?php esc_html_e('No posts found.', 'my-custom-theme'); ?></p>
<?php
endif;
?>
</main>
<footer class="site-footer container">
<p>© <?php echo esc_html(gmdate('Y')); ?> <?php bloginfo('name'); ?></p>
</footer>
<?php wp_footer(); ?>
</body>
</html>
Save these two files, open Appearance -> Themes in your WordPress dashboard, and you will see “My Custom Theme” ready to activate.
While two files make a valid theme, real-world development requires a modular folder structure for scalability and maintainability.
Production Folder Structure
A well-organized classic theme separates logic, assets, and template components into dedicated directories:
my-custom-theme/
|-- assets/
| |-- css/
| | |-- main.css
| |-- js/
| | |-- navigation.js
| | |-- main.js
| |-- images/
|-- inc/
| |-- template-tags.php
| |-- customizer.php
|-- template-parts/
| |-- content.php
| |-- content-single.php
| |-- content-page.php
| |-- content-none.php
|-- 404.php
|-- archive.php
|-- footer.php
|-- functions.php
|-- header.php
|-- index.php
|-- page.php
|-- screenshot.png
|-- search.php
|-- sidebar.php
|-- single.php
|-- style.css
2. The WordPress Template Hierarchy Tree
When a visitor visits a URL on your WordPress site, WordPress parses the request, queries the database, and searches your active theme directory for the most specific template file available. If that specific file does not exist, it falls back through a defined hierarchy until it reaches index.php.
Understanding this hierarchy prevents you from duplicating template code or fighting WordPress core URL routing.
How the Cascade Works
Here is how WordPress selects templates for common page types:
[Visitor Requests Single Blog Post]
|
v
1. single-{post-type}-{slug}.php (e.g., single-post-hello-world.php)
|
v (if not found)
2. single-{post-type}.php (e.g., single-post.php)
|
v (if not found)
3. single.php
|
v (if not found)
4. singular.php
|
v (if not found)
5. index.php
[Visitor Requests Static Page]
|
v
1. custom-template.php (Selected in page editor attributes)
|
v (if not assigned)
2. page-{slug}.php (e.g., page-about-us.php)
|
v (if not found)
3. page-{id}.php (e.g., page-42.php)
|
v (if not found)
4. page.php
|
v (if not found)
5. singular.php
|
v (if not found)
6. index.php
[Visitor Requests Category Archive]
|
v
1. category-{slug}.php (e.g., category-news.php)
|
v (if not found)
2. category-{id}.php (e.g., category-7.php)
|
v (if not found)
3. category.php
|
v (if not found)
4. archive.php
|
v (if not found)
5. index.php
[Visitor Requests Author Archive]
|
v
1. author-{nicename}.php (e.g., author-jane.php)
|
v (if not found)
2. author-{id}.php (e.g., author-2.php)
|
v (if not found)
3. author.php
|
v (if not found)
4. archive.php
|
v (if not found)
5. index.php
[Visitor Encounters 404 Not Found]
|
v
1. 404.php
|
v (if not found)
2. index.php
[Visitor Performs Search]
|
v
1. search.php
|
v (if not found)
2. index.php
The design principle here is simple: specific to generic. You only need to create specialized files when a particular post type, taxonomy, or landing page requires unique layout structure.
3. The WordPress Loop: Processing Posts
The Loop is the PHP code block that queries and displays posts for any given template file. Whenever WordPress loads a page, it automatically executes the main query based on the URL and populates the global $wp_query object.
The Canonical Loop Structure
Every loop in WordPress follows this fundamental pattern:
<?php
if (have_posts()) :
while (have_posts()) : the_post();
?>
<article id="post-<?php the_ID(); ?>" <?php post_class('entry'); ?>>
<header class="entry-header">
<?php
if (is_singular()) :
the_title('<h1 class="entry-title">', '</h1>');
else :
the_title('<h2 class="entry-title"><a href="' . esc_url(get_permalink()) . '" rel="bookmark">', '</a></h2>');
endif;
?>
<div class="entry-meta">
<span class="posted-on">
<?php echo esc_html(get_the_date()); ?>
</span>
<span class="byline">
<?php echo esc_html__('by', 'my-custom-theme') . ' ' . esc_html(get_the_author()); ?>
</span>
</div>
</header>
<?php if (has_post_thumbnail() && !is_singular()) : ?>
<div class="post-thumbnail">
<a href="<?php the_permalink(); ?>">
<?php the_post_thumbnail('medium_large'); ?>
</a>
</div>
<?php endif; ?>
<div class="entry-content">
<?php
if (is_singular()) :
the_content();
wp_link_pages(array(
'before' => '<div class="page-links">' . esc_html__('Pages:', 'my-custom-theme'),
'after' => '</div>',
));
else :
the_excerpt();
endif;
?>
</div>
</article>
<?php
endwhile;
// Pagination for archive pages
the_posts_pagination(array(
'mid_size' => 2,
'prev_text' => esc_html__('Previous', 'my-custom-theme'),
'next_text' => esc_html__('Next', 'my-custom-theme'),
));
else :
?>
<section class="no-results not-found">
<h2><?php esc_html_e('Nothing Found', 'my-custom-theme'); ?></h2>
<p><?php esc_html_e('It seems we cannot find what you are looking for. Perhaps searching can help.', 'my-custom-theme'); ?></p>
<?php get_search_form(); ?>
</section>
<?php
endif;
?>
What Happens Inside the Loop
have_posts(): A boolean check that returnstrueif there are posts left in the current query array to loop through.the_post(): Advances the internal loop index counter, retrieves the next post item, and sets up global post data so template tags work without passing an explicit$post_idargument.post_class('entry'): Outputs context-aware CSS classes onto the<article>element (such aspost-12,type-post,status-publish,format-standard,has-post-thumbnail,sticky). Always include this helper function to maintain standard CSS hooks.the_ID(): Outputs the numeric database ID of the current post.
4. Registering Assets via wp_enqueue_scripts
One of the most common beginner mistakes is hardcoding <link rel="stylesheet"> or <script src="..."> tags directly inside header.php or footer.php.
Hardcoding assets creates three major problems:
- It breaks script dependencies (e.g., loading a plugin script before its required library).
- It prevents plugins from optimizing, concatenating, or minifying assets.
- It risks duplicate script executions across different components.
WordPress provides a centralized API for registering and enqueuing stylesheets and scripts through the wp_enqueue_scripts action hook in functions.php.
Enqueueing in functions.php
Open functions.php and add your asset registrations:
<?php
/**
* Theme functions and asset management.
*/
function mytheme_scripts() {
$theme_version = wp_get_theme()->get('Version');
// Enqueue primary stylesheet
wp_enqueue_style(
'mytheme-main-style',
get_template_directory_uri() . '/assets/css/main.css',
array(),
$theme_version,
'all'
);
// Enqueue theme style.css for metadata/custom overrides
wp_enqueue_style(
'mytheme-root-style',
get_stylesheet_uri(),
array('mytheme-main-style'),
$theme_version
);
// Enqueue navigation JavaScript
wp_enqueue_script(
'mytheme-navigation',
get_template_directory_uri() . '/assets/js/navigation.js',
array(),
$theme_version,
array(
'strategy' => 'defer',
'in_footer' => true,
)
);
// Enqueue threaded comments script on single posts when comments are open
if (is_singular() && comments_open() && get_option('thread_comments')) {
wp_enqueue_script('comment-reply');
}
}
add_action('wp_enqueue_scripts', 'mytheme_scripts');
Key Parameters Explained
- Handle (
$handle): A unique string identifier (e.g.,'mytheme-main-style'). Use this handle to define dependencies or dequeue files when needed. - Source (
$src): The full URL path to the file. Useget_template_directory_uri()for parent themes andget_stylesheet_directory_uri()for child themes. - Dependencies (
$deps): An array of handles that must be loaded before this file. For example,array('jquery'). - Version (
$ver): A version string appended as a query parameter (e.g.,?ver=1.0.0) for browser cache busting. In production, usewp_get_theme()->get('Version'). In active local development, you can usefilemtime(get_template_directory() . '/assets/css/main.css')to bust the cache on every file save. - Strategy & Placement: In modern WordPress (6.3+), you can pass an associative array specifying
'strategy' => 'defer'or'strategy' => 'async'alongside'in_footer' => trueto eliminate render-blocking script execution.
The Mandatory Core Hooks
For the enqueuing system (and most third-party plugins) to work, your theme must contain two template tags:
wp_head(): Placed directly before the closing</head>tag inheader.php.wp_footer(): Placed directly before the closing</body>tag infooter.php.
If you forget either of these tags, styles will not load, analytics trackers will fail, and administrative toolbars will disappear.
5. Template Parts: Modular Component Architecture
When building templates, you will find yourself reusing the same markup patterns across multiple files. For instance, the HTML structure for a post card on index.php, archive.php, search.php, and category.php is often identical.
Instead of copying and pasting the Loop markup into four separate files, split it into reusable template parts using get_template_part().
Using get_template_part
Create a file named template-parts/content.php:
<?php
/**
* Template part for displaying standard post items in archive listings.
*/
?>
<article id="post-<?php the_ID(); ?>" <?php post_class('post-card'); ?>>
<?php if (has_post_thumbnail()) : ?>
<div class="post-card__image">
<a href="<?php the_permalink(); ?>">
<?php the_post_thumbnail('medium'); ?>
</a>
</div>
<?php endif; ?>
<div class="post-card__body">
<header class="post-card__header">
<div class="post-card__categories">
<?php the_category(', '); ?>
</div>
<h2 class="post-card__title">
<a href="<?php the_permalink(); ?>"><?php the_title(); ?></a>
</h2>
</header>
<div class="post-card__excerpt">
<?php the_excerpt(); ?>
</div>
<footer class="post-card__footer">
<time datetime="<?php echo esc_attr(get_the_date('c')); ?>">
<?php echo esc_html(get_the_date()); ?>
</time>
</footer>
</div>
</article>
Now, your index.php or archive.php becomes clean and readable:
<?php
get_header();
?>
<main id="primary" class="site-main container">
<?php
if (have_posts()) :
?>
<header class="page-header">
<?php
the_archive_title('<h1 class="page-title">', '</h1>');
the_archive_description('<div class="archive-description">', '</div>');
?>
</header>
<div class="posts-grid">
<?php
while (have_posts()) : the_post();
get_template_part('template-parts/content', get_post_type());
endwhile;
?>
</div>
<?php
the_posts_pagination();
else :
get_template_part('template-parts/content', 'none');
endif;
?>
</main>
<?php
get_sidebar();
get_footer();
Notice the call get_template_part('template-parts/content', get_post_type()). If the current post type is a custom post type named book, WordPress looks for template-parts/content-book.php. If that file does not exist, it falls back automatically to template-parts/content.php.
Passing Custom Arguments to Template Parts
Since WordPress 5.5, get_template_part() accepts a third argument: an associative array of custom parameters accessible inside the template part via $args.
In your parent template:
get_template_part('template-parts/content', 'card', array(
'show_excerpt' => false,
'badge_label' => __('Featured', 'my-custom-theme'),
));
Inside template-parts/content-card.php:
$show_excerpt = isset($args['show_excerpt']) ? $args['show_excerpt'] : true;
$badge_label = isset($args['badge_label']) ? $args['badge_label'] : '';
if (!empty($badge_label)) {
echo '<span class="badge">' . esc_html($badge_label) . '</span>';
}
6. Custom Database Queries: WP_Query vs query_posts
A frequent requirement in theme development is creating secondary queries: displaying the latest three news articles on the homepage, rendering related case studies below a post, or building a custom grid for a Custom Post Type.
The Fatal Flaw of query_posts()
If you search older WordPress tutorials, you will encounter examples using query_posts().
Never use query_posts(). It is a dangerous anti-pattern that creates major bugs:
- It overwrites the global main query: It modifies the global
$wp_queryobject directly, breaking conditional tags (is_single(),is_page()) and confusing other plugins. - It doubles database workload: WordPress already executes the main query for the current URL before reaching your template. Calling
query_posts()forces WordPress to re-run an entirely new SQL query against the database, throwing away the previous result. - It breaks pagination: It corrupts the
pagedparameter, causing page numbers to return 404 errors or display identical posts on subsequent pages.
The Correct Secondary Query: WP_Query
When you need an independent loop that does not interfere with the main page request, instantiate a new WP_Query object:
<?php
$featured_args = array(
'post_type' => 'post',
'posts_per_page' => 3,
'post_status' => 'publish',
'category_name' => 'featured',
'no_found_rows' => true, // Performance optimization: skips SQL_CALC_FOUND_ROWS if pagination is not needed
'update_post_meta_cache' => true,
'update_post_term_cache' => true,
);
$featured_query = new WP_Query($featured_args);
if ($featured_query->have_posts()) :
?>
<section class="featured-posts">
<h2><?php esc_html_e('Featured Stories', 'my-custom-theme'); ?></h2>
<div class="grid">
<?php
while ($featured_query->have_posts()) : $featured_query->the_post();
?>
<div class="featured-card">
<h3><a href="<?php the_permalink(); ?>"><?php the_title(); ?></a></h3>
<p><?php echo esc_html(wp_trim_words(get_the_excerpt(), 20)); ?></p>
</div>
<?php
endwhile;
?>
</div>
</section>
<?php
// CRITICAL: Always reset post data after a custom WP_Query loop
wp_reset_postdata();
endif;
?>
Why wp_reset_postdata() is Required
When $featured_query->the_post() runs, it temporarily overwrites the global $post variable to match the current item in the secondary query.
If you do not call wp_reset_postdata() immediately after your custom loop ends, subsequent template tags (and your footer template) will reference the last post from your secondary query instead of the actual page post.
Modifying the Main Query: pre_get_posts
What if you need to alter the main query itself? For example:
- You want your search results page to display 20 items instead of the default 10.
- You want your category archive to exclude a specific subcategory.
- You want to include a custom post type (
portfolio) in your main blog archive.
Do not use WP_Query inside your template files to replace the main loop. Instead, use the pre_get_posts action hook in functions.php to alter the SQL query before it executes in the database.
/**
* Modify main archive query parameters before execution.
*/
function mytheme_modify_main_queries($query) {
// Only modify front-end requests on the main query
if (is_admin() || !$query->is_main_query()) {
return;
}
// Include custom post types in search results
if ($query->is_search()) {
$query->set('post_type', array('post', 'page', 'portfolio'));
}
// Set custom post limit on portfolio archive
if ($query->is_post_type_archive('portfolio')) {
$query->set('posts_per_page', 12);
}
}
add_action('pre_get_posts', 'mytheme_modify_main_queries');
Using pre_get_posts executes only one database query, keeps pagination intact, and avoids template-level query hacks.
7. Theme Setup and Essential Feature Registration
Before your theme can handle post thumbnails, custom logos, navigation menus, and title tags, you must explicitly register support for those features inside functions.php hooked to after_setup_theme.
/**
* Register core theme supports and navigation menus.
*/
function mytheme_setup() {
// Let WordPress manage the document <title> tag automatically
add_theme_support('title-tag');
// Enable Featured Images (Post Thumbnails)
add_theme_support('post-thumbnails');
// Register custom image crop sizes
add_image_size('card-thumb', 600, 400, true); // Hard crop
add_image_size('hero-banner', 1400, 600, true);
// Switch default core markup to valid HTML5
add_theme_support('html5', array(
'search-form',
'comment-form',
'comment-list',
'gallery',
'caption',
'style',
'script',
));
// Enable custom logo support via Site Identity customizer
add_theme_support('custom-logo', array(
'height' => 80,
'width' => 240,
'flex-height' => true,
'flex-width' => true,
));
// Register navigation menu locations
register_nav_menus(array(
'primary' => __('Primary Header Menu', 'my-custom-theme'),
'footer' => __('Footer Navigation Menu', 'my-custom-theme'),
));
// Enable Gutenberg wide and full alignment
add_theme_support('align-wide');
// Enable responsive embedded content (YouTube, Vimeo)
add_theme_support('responsive-embeds');
}
add_action('after_setup_theme', 'mytheme_setup');
Rendering Menus in Templates
Once registered, display your menus in header.php or footer.php using wp_nav_menu():
<nav class="primary-nav" aria-label="<?php esc_attr_e('Primary Navigation', 'my-custom-theme'); ?>">
<?php
wp_nav_menu(array(
'theme_location' => 'primary',
'container' => false,
'menu_class' => 'primary-nav__list',
'fallback_cb' => false,
'depth' => 2,
));
?>
</nav>
8. Theme Security and Output Escaping
Because WordPress powers millions of websites, sloppy code leads to cross-site scripting (XSS) vulnerabilities. A clean theme treats all data (even data stored in the WordPress database) as untrusted when rendering it to the screen.
The Rule: Escape Late
Always escape variables at the exact moment of output.
| Data Context | Function | Example |
|---|---|---|
| Plain text inside HTML tags | esc_html() | <p><?php echo esc_html($user_bio); ?></p> |
| HTML attribute values | esc_attr() | <input value="<?php echo esc_attr($query); ?>"> |
URLs in href or src | esc_url() | <a href="<?php echo esc_url($external_link); ?>"> |
| Safe HTML strings | wp_kses_post() | <div><?php echo wp_kses_post($custom_html); ?></div> |
| Translation + Escaping | esc_html__() | <span><?php echo esc_html__('Read More', 'mytheme'); ?></span> |
Never do this:
<!-- VULNERABLE: Direct echo without escaping -->
<a href="<?php echo $custom_url; ?>" class="<?php echo $custom_class; ?>">
<?php echo $custom_label; ?>
</a>
Always do this:
<!-- SECURE: Explicitly escaped contexts -->
<a href="<?php echo esc_url($custom_url); ?>" class="<?php echo esc_attr($custom_class); ?>">
<?php echo esc_html($custom_label); ?>
</a>
9. Performance Fundamentals in Custom Themes
A well-coded custom theme should load in under 500 milliseconds on a standard server without needing five heavy caching plugins. Here are the core habits that keep your theme fast:
1. Stop Enqueuing Unnecessary Core Assets
By default, WordPress loads emoji detection scripts and default block library styles on every page request. If your custom theme uses its own styling or does not require legacy emoji converters, deregister them in functions.php:
/**
* Disable emoji scripts and unneeded header meta tags.
*/
function mytheme_clean_head() {
remove_action('wp_head', 'print_emoji_detection_script', 7);
remove_action('wp_print_styles', 'print_emoji_styles');
remove_action('admin_print_scripts', 'print_emoji_detection_script');
remove_action('admin_print_styles', 'print_emoji_styles');
remove_action('wp_head', 'rsd_link');
remove_action('wp_head', 'wlwmanifest_link');
remove_action('wp_head', 'wp_generator');
}
add_action('init', 'mytheme_clean_head');
2. Leverage Native Responsive Images
Never hardcode raw <img> tags pointing to media upload URLs. Always use WordPress attachment helper functions:
// Bad: Loads fixed resolution without srcset
<img src="<?php echo esc_url($image_url); ?>" alt="Banner">
// Good: Automatically generates srcset, sizes, loading="lazy", and decoding="async"
<?php echo wp_get_attachment_image($image_id, 'hero-banner', false, array('class' => 'hero-media')); ?>
Using wp_get_attachment_image() ensures mobile devices download appropriately sized images rather than full desktop assets.
3. Avoid N+1 Query Traps in Loops
If you have a loop displaying 20 posts and you make individual database requests (like retrieving post metadata or custom taxonomy terms) one by one inside each loop iteration, you create an N+1 query problem.
Ensure your WP_Query arguments leave caching flags enabled ('update_post_meta_cache' => true and 'update_post_term_cache' => true), which instructs WordPress core to batch-load all metadata and terms for every post in the query in one database call.
10. Local Development and Debugging Toolkit
Building themes without a proper local environment and debug configuration is like driving at night with the headlights off.
Configure wp-config.php for Development
In your local test site, open wp-config.php and set debugging flags:
define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);
define('WP_DEBUG_DISPLAY', false);
define('SCRIPT_DEBUG', true);
define('SAVEQUERIES', true);
WP_DEBUG_LOG: Writes all PHP warnings, deprecated notices, and fatal errors towp-content/debug.log.WP_DEBUG_DISPLAY: Hides error stacks from breaking the visual browser layout.SCRIPT_DEBUG: Forces WordPress core to load unminified development versions of core CSS and JavaScript files for easier debugging.
Two Essential Developer Plugins
- Query Monitor: The gold standard debugging plugin for WordPress. It inspects database queries, execution time, memory usage, template hierarchy selection, enqueued assets, and active hooks on every page request.
- Theme Check: Verifies that your theme meets standard WordPress coding guidelines and flags deprecated functions, missing text domains, or security gaps.
Summary Checklist for Your First Custom Theme
When building your theme from scratch, use this progression checklist:
- Create the folder: Add
style.css(with headers) andindex.php. - Set up
functions.php: Register theme features (title-tag,post-thumbnails,html5,nav_menus) onafter_setup_theme. - Enqueue assets: Load CSS and JS using
wp_enqueue_scriptswith proper versions anddeferstrategies. - Build the layout frame: Create
header.phpandfooter.php, includingwp_head()andwp_footer(). - Implement the Loop: Render posts using semantic HTML,
post_class(), and proper escaping. - Break out template parts: Isolate cards and reusable blocks into
/template-parts/. - Expand the hierarchy: Add
single.php,page.php,archive.php,search.php, and404.phpas needed. - Handle custom queries: Use
WP_Querywithwp_reset_postdata()for secondary loops andpre_get_postsfor main query modifications. - Test with Query Monitor: Check total SQL queries, memory footprint, and ensure zero PHP warnings in
debug.log.
Building themes from scratch demystifies WordPress. Once you master the template hierarchy, the Loop, asset enqueuing, and clean query handling, you can build any layout without relying on fragile page builders or massive third-party starter themes.
Changes
| Pass | What changed | Examples |
|---|---|---|
| Structure | Transformed outdated link list into a full technical roadmap | 6 bare URLs -> 10 comprehensive architectural sections |
| Inflation | Removed promotional language and vague generalities | “set you apart from the lot” -> deleted |
| Vocabulary | Stripped AI buzzwords and metaphors | “journey”, “landscape”, “delve” -> dropped |
| Grammar | Fixed copula avoidance and passive phrasing | “serves as the fallback” -> “is the master fallback” |
| Rhythm/Style | Varied sentence lengths with direct developer tone | “Never use query_posts.” “That is how it works.” |
| Hedging/Filler | Cut introductory throat-clearing and metadata links | “I have selected these posts based on…” -> deleted |
| Transitions | Removed repetitive connectors | “Moreover”, “Additionally” -> natural progression |
| Soul | Injected practical debugging traps and real-world advice | wp-config.php setup, N+1 query warnings, wp_reset_postdata |