diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d20ec3b..d75cbf9 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -75,8 +75,11 @@ jobs:
       - name: Build E2E.Templates.AutoDiscovery
         run: dotnet build tests/e2e/E2E.Templates.AutoDiscovery/E2E.Templates.AutoDiscovery.csproj -c Release
 
-      - name: Build E2E.Templates.PreBuiltZip
-        run: dotnet build tests/e2e/E2E.Templates.PreBuiltZip/E2E.Templates.PreBuiltZip.csproj -c Release
+      - name: Build E2E.Templates.Reference
+        run: dotnet build tests/e2e/E2E.Templates.Reference/E2E.Templates.Reference.csproj -c Release
+
+      - name: Build E2E.Templates.ReferenceManual
+        run: dotnet build tests/e2e/E2E.Templates.ReferenceManual/E2E.Templates.ReferenceManual.csproj -c Release
 
       - name: Build E2E.Templates.ManualWithSubPath
         run: dotnet build tests/e2e/E2E.Templates.ManualWithSubPath/E2E.Templates.ManualWithSubPath.csproj -c Release
@@ -106,6 +109,28 @@ jobs:
           if ($files -notcontains "NewClass.vstemplate") { throw "Missing ItemTemplates/NewClass/NewClass.vstemplate" }
           Write-Host "E2E.Templates.AutoDiscovery VSIX verified successfully"
 
+      - name: Verify E2E.Templates.Reference VSIX
+        run: |
+          $vsix = "tests/e2e/E2E.Templates.Reference/bin/Release/net472/E2E.Templates.Reference.vsix"
+          if (!(Test-Path $vsix)) { throw "VSIX not found: $vsix" }
+          Expand-Archive -Path $vsix -DestinationPath "tests/e2e/E2E.Templates.Reference/vsix-contents" -Force
+          $files = Get-ChildItem -Path "tests/e2e/E2E.Templates.Reference/vsix-contents" -Recurse | Select-Object -ExpandProperty Name
+          # Verify templates copied from referenced project are included
+          if ($files -notcontains "RefProject.vstemplate") { throw "Missing ProjectTemplates/ProjectTemplate/RefProject.vstemplate" }
+          if ($files -notcontains "RefItem.vstemplate") { throw "Missing ItemTemplates/ItemTemplate/RefItem.vstemplate" }
+          Write-Host "E2E.Templates.Reference VSIX verified successfully"
+
+      - name: Verify E2E.Templates.ReferenceManual VSIX
+        run: |
+          $vsix = "tests/e2e/E2E.Templates.ReferenceManual/bin/Release/net472/E2E.Templates.ReferenceManual.vsix"
+          if (!(Test-Path $vsix)) { throw "VSIX not found: $vsix" }
+          Expand-Archive -Path $vsix -DestinationPath "tests/e2e/E2E.Templates.ReferenceManual/vsix-contents" -Force
+          $files = Get-ChildItem -Path "tests/e2e/E2E.Templates.ReferenceManual/vsix-contents" -Recurse | Select-Object -ExpandProperty Name
+          # Verify templates copied from referenced project are included (manual manifest)
+          if ($files -notcontains "RefProject.vstemplate") { throw "Missing ProjectTemplates/ProjectTemplate/RefProject.vstemplate" }
+          if ($files -notcontains "RefItem.vstemplate") { throw "Missing ItemTemplates/ItemTemplate/RefItem.vstemplate" }
+          Write-Host "E2E.Templates.ReferenceManual VSIX verified successfully"
+
       - name: Verify E2E.AllFeatures VSIX
         run: |
           $vsix = "tests/e2e/E2E.AllFeatures/bin/Release/net472/E2E.AllFeatures.vsix"
diff --git a/docs/templates.md b/docs/templates.md
index 7fef526..598a96e 100644
--- a/docs/templates.md
+++ b/docs/templates.md
@@ -6,19 +6,30 @@ This document explains how to include Visual Studio project templates and item t
 
 The built-in VSIX Manifest Designer in Visual Studio cannot enumerate SDK-style projects when adding template assets. This is because the designer uses legacy DTE extenders that are registered for the old project system, not the Common Project System (CPS) used by SDK-style projects.
 
-Additionally, SDK-style projects don't define the `TemplateProjectOutputGroup` and `ItemTemplateOutputGroup` MSBuild output groups that VSSDK expects for template assets.
+This SDK provides MSBuild-based template support that works around these limitations by:
+- Auto-discovering templates in standard folders
+- Supporting cross-project template references
+- Providing validation warnings for missing manifest Content entries
 
-This SDK provides MSBuild-based template support that bypasses these limitations entirely.
+## How It Works
+
+This SDK handles template packaging by:
+
+1. **Auto-discovering** templates in `ProjectTemplates/` and `ItemTemplates/` folders
+2. **Including template files** in the VSIX package automatically
+3. **Supporting cross-project template references** for including templates from other SDK-style projects
+4. **Providing validation warnings** if your manifest is missing required Content entries
+
+Your manifest must contain `<Content><ProjectTemplate/></Content>` entries for Visual Studio to register and display templates. The SDK includes the template files in the VSIX; the manifest entries tell VS how to find and register them.
 
 ## Item Types
 
-The SDK provides four item types for including templates:
+The SDK provides the following item types for templates:
 
 | Item Type | Description |
 |-----------|-------------|
-| `VsixProjectTemplate` | A folder containing a `.vstemplate` file for a project template |
-| `VsixItemTemplate` | A folder containing a `.vstemplate` file for an item template |
-| `VsixTemplateZip` | A pre-built template zip file |
+| `VsixProjectTemplate` | (Auto-discovered) A folder containing a `.vstemplate` file for a project template |
+| `VsixItemTemplate` | (Auto-discovered) A folder containing a `.vstemplate` file for an item template |
 | `VsixTemplateReference` | Reference a template folder from another project |
 
 ## Auto-Discovery
@@ -45,10 +56,12 @@ MyExtension/
       MyClass.cs
 ```
 
-With this structure, no additional configuration is needed. The SDK will:
+With this structure, minimal configuration is needed. The SDK will:
 1. Find the templates automatically
-2. Zip each template folder during build
-3. Include the zips in the VSIX at `ProjectTemplates/` and `ItemTemplates/`
+2. Include all template files in the VSIX
+3. Warn if `<Content>` entries are missing from the manifest
+
+You need to add the Content entries to your manifest manually (see Manifest Configuration below).
 
 ### Disabling Auto-Discovery
 
@@ -71,33 +84,9 @@ To use different folder names:
 </PropertyGroup>
 ```
 
-## Manual Template Configuration
-
-### Folder-Based Templates
-
-If your templates are in non-standard locations, add them explicitly:
-
-```xml
-<ItemGroup>
-  <VsixProjectTemplate Include="MyTemplates\ConsoleApp" />
-  <VsixItemTemplate Include="MyTemplates\NewClass" />
-</ItemGroup>
-```
-
-### Pre-Built Template Zips
-
-If you have pre-built template zip files:
-
-```xml
-<ItemGroup>
-  <VsixTemplateZip Include="Templates\MyTemplate.zip" TemplateType="Project" />
-  <VsixTemplateZip Include="Templates\MyItem.zip" TemplateType="Item" />
-</ItemGroup>
-```
-
-### Template References
+## Cross-Project Template References
 
-To include a template from another project in your solution:
+When you have templates in a separate SDK-style project that the VSIX Manifest Designer cannot enumerate, use `VsixTemplateReference`:
 
 ```xml
 <ItemGroup>
@@ -107,6 +96,10 @@ To include a template from another project in your solution:
 </ItemGroup>
 ```
 
+The SDK will:
+1. Copy the template folder from the referenced project to your local `ProjectTemplates/` or `ItemTemplates/` folder
+2. Include the copied template files in the VSIX
+
 The `TemplatePath` is relative to the referenced project's directory.
 
 ## Manifest Configuration
@@ -120,24 +113,10 @@ Visual Studio requires `<Content>` entries in your `.vsixmanifest` to register t
 </Content>
 ```
 
-The SDK will emit warnings if you have templates defined but missing manifest entries:
+The SDK will emit warnings if you have templates but missing manifest entries:
 - **VSIXSDK011**: Project templates defined but no `<ProjectTemplate>` in manifest
 - **VSIXSDK012**: Item templates defined but no `<ItemTemplate>` in manifest
 
-## Target Subfolders
-
-To organize templates into subfolders within the VSIX:
-
-```xml
-<ItemGroup>
-  <!-- Will be placed at ProjectTemplates/CSharp/ -->
-  <VsixProjectTemplate Include="ProjectTemplates\MyTemplate" TargetSubPath="CSharp" />
-
-  <!-- Will be placed at ItemTemplates/Web/ -->
-  <VsixItemTemplate Include="ItemTemplates\MyItem" TargetSubPath="Web" />
-</ItemGroup>
-```
-
 ## Complete Example
 
 ### Project File
@@ -149,7 +128,9 @@ To organize templates into subfolders within the VSIX:
     <Version>1.0.0</Version>
   </PropertyGroup>
 
-  <!-- Templates are auto-discovered, but you can add more explicitly -->
+  <!-- Templates in ProjectTemplates/ and ItemTemplates/ are auto-discovered -->
+
+  <!-- Include templates from another SDK-style project -->
   <ItemGroup>
     <VsixTemplateReference Include="..\SharedTemplates\SharedTemplates.csproj"
                            TemplateType="Project"
@@ -161,6 +142,8 @@ To organize templates into subfolders within the VSIX:
 
 ### Manifest File
 
+Add the `<Content>` entries for your templates:
+
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
 <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011">
@@ -206,7 +189,6 @@ To organize templates into subfolders within the VSIX:
 
 | Code | Description |
 |------|-------------|
-| VSIXSDK010 | `VsixTemplateZip` item missing `TemplateType` metadata |
 | VSIXSDK011 | Project templates defined but no `<ProjectTemplate>` in manifest |
 | VSIXSDK012 | Item templates defined but no `<ItemTemplate>` in manifest |
 | VSIXSDK013 | `VsixTemplateReference` item missing `TemplateType` metadata |
@@ -217,7 +199,7 @@ To organize templates into subfolders within the VSIX:
 ### Templates not appearing in Visual Studio
 
 1. Ensure your manifest has the appropriate `<Content>` entries
-2. Check that the template zip files are included in the VSIX (open the .vsix as a zip)
+2. Check that the template folders are included in the VSIX (open the .vsix as a zip)
 3. Verify the `.vstemplate` file has correct `<ProjectType>` or `<TemplateGroupID>`
 4. Reset the Visual Studio template cache: delete `%LocalAppData%\Microsoft\VisualStudio\<version>\ComponentModelCache`
 
@@ -225,6 +207,9 @@ To organize templates into subfolders within the VSIX:
 
 Ensure the template folder exists and contains a `.vstemplate` file. For `VsixTemplateReference`, verify the `TemplatePath` is correct relative to the referenced project.
 
-### Templates in wrong location in VSIX
+### Cross-project templates not working
 
-Check the `TargetSubPath` metadata if you're using custom paths. By default, templates are placed directly in `ProjectTemplates/` or `ItemTemplates/`.
+1. Verify the referenced project path is correct
+2. Check that `TemplateType` is set to `Project` or `Item`
+3. Ensure `TemplatePath` points to a folder containing a `.vstemplate` file
+4. The template folder will be copied to your local `ProjectTemplates/` or `ItemTemplates/` folder during build
diff --git a/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.props b/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.props
index eaff8a6..7f672e6 100644
--- a/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.props
+++ b/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.props
@@ -2,11 +2,16 @@
   <!--
     CodingWithCalvin.VsixSdk - Sdk.Vsix.Templates.props
 
-    Template support for VSIX projects. Defines item types for including
-    project templates and item templates in VSIX packages.
+    Template support for VSIX projects. Defines properties and item types
+    for including project templates and item templates in VSIX packages.
 
-    This bypasses the broken VSIX Manifest Designer which cannot enumerate
-    SDK-style projects for template assets.
+    Features:
+    - Auto-discovery of templates in ProjectTemplates/ and ItemTemplates/ folders
+    - Cross-project template references via VsixTemplateReference
+    - Validation warnings for missing manifest Content entries
+
+    Note: VSSDK handles the actual template packaging. This SDK provides
+    discovery, validation, and convenience features on top of VSSDK.
   -->
 
   <PropertyGroup>
@@ -28,23 +33,22 @@
   <!--
     Item type definitions:
 
-    VsixProjectTemplate  - A folder containing a .vstemplate file for a project template
-                           Will be zipped and included in the VSIX at ProjectTemplates/
-
-    VsixItemTemplate     - A folder containing a .vstemplate file for an item template
-                           Will be zipped and included in the VSIX at ItemTemplates/
+    VsixProjectTemplate  - (Auto-discovered) A folder containing a .vstemplate file for a project template.
+                           Discovered automatically in the ProjectTemplates/ folder.
+                           VSSDK packages these based on manifest Content entries.
 
-    VsixTemplateZip      - A pre-built template zip file to include directly
-                           Specify TemplateType="Project" or TemplateType="Item"
+    VsixItemTemplate     - (Auto-discovered) A folder containing a .vstemplate file for an item template.
+                           Discovered automatically in the ItemTemplates/ folder.
+                           VSSDK packages these based on manifest Content entries.
 
-    VsixTemplateReference - Reference a template folder from another project
-                            Specify TemplateType="Project" or TemplateType="Item"
-                            TemplatePath is relative to the referenced project directory
+    VsixTemplateReference - Reference a template folder from another project.
+                            Useful when the VSIX Manifest Designer cannot enumerate SDK-style projects.
+                            Templates are copied to the local template folder so VSSDK can package them.
 
     Usage:
-      <VsixProjectTemplate Include="ProjectTemplates\MyTemplate" />
-      <VsixItemTemplate Include="ItemTemplates\MyItem" />
-      <VsixTemplateZip Include="Templates\PreBuilt.zip" TemplateType="Project" />
+      (Templates in ProjectTemplates/ and ItemTemplates/ are auto-discovered)
+
+      (Reference templates from another SDK-style project)
       <VsixTemplateReference Include="..\MyTemplateProject\MyTemplateProject.csproj"
                              TemplateType="Project"
                              TemplatePath="Templates\MyProjectTemplate" />
@@ -61,13 +65,6 @@
       <TargetSubPath></TargetSubPath>
     </VsixItemTemplate>
 
-    <VsixTemplateZip>
-      <!-- Must specify Project or Item -->
-      <TemplateType></TemplateType>
-      <!-- Optional subfolder within the template type folder -->
-      <TargetSubPath></TargetSubPath>
-    </VsixTemplateZip>
-
     <VsixTemplateReference>
       <!-- Must specify Project or Item -->
       <TemplateType></TemplateType>
diff --git a/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.targets b/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.targets
index 8c5080d..d6fa714 100644
--- a/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.targets
+++ b/src/CodingWithCalvin.VsixSdk/Sdk/Sdk.Vsix.Templates.targets
@@ -2,23 +2,21 @@
   <!--
     CodingWithCalvin.VsixSdk - Sdk.Vsix.Templates.targets
 
-    Build targets for VSIX template support. Handles:
-    - Auto-discovery of template folders
-    - Zipping folder-based templates
-    - Including templates in VSIX output
+    Template support for VSIX projects. Handles:
+    - Auto-discovery of template folders for validation
+    - Copying templates from referenced projects (VsixTemplateReference)
     - Validation warnings for manifest configuration
-  -->
 
-  <PropertyGroup>
-    <!-- Intermediate folder for zipped templates -->
-    <_VsixTemplateIntermediateOutputPath>$(IntermediateOutputPath)VsixTemplates\</_VsixTemplateIntermediateOutputPath>
-  </PropertyGroup>
+    Note: VSSDK handles template packaging when the manifest contains
+    <Content><ProjectTemplate/></Content> entries. This file provides
+    discovery, cross-project template support, and validation.
+  -->
 
   <!--
-    Auto-discover project and item templates.
-    Discovery must happen in a target because we need to compute additional metadata.
+    Auto-discover project and item templates for validation.
+    VSSDK handles the actual packaging based on manifest Content entries.
   -->
-  <Target Name="DiscoverVsixTemplates" BeforeTargets="PrepareVsixTemplates">
+  <Target Name="DiscoverVsixTemplates" BeforeTargets="GetVsixSourceItems">
     <!-- Find all .vstemplate files in ProjectTemplates subfolders -->
     <ItemGroup Condition="'$(EnableDefaultVsixTemplateItems)' == 'true' and '$(EnableDefaultItems)' != 'false'">
       <_DiscoveredProjectTemplateFiles Include="$(MSBuildProjectDirectory)\$(VsixProjectTemplatesFolder)\**\*.vstemplate"
@@ -27,10 +25,9 @@
                                      Condition="Exists('$(MSBuildProjectDirectory)\$(VsixItemTemplatesFolder)')" />
     </ItemGroup>
 
-    <!-- Create VsixProjectTemplate items - use the parent directory of the .vstemplate file -->
+    <!-- Create VsixProjectTemplate items for validation -->
     <ItemGroup Condition="'@(_DiscoveredProjectTemplateFiles)' != ''">
       <VsixProjectTemplate Include="@(_DiscoveredProjectTemplateFiles->'%(RootDir)%(Directory)')">
-        <!-- Compute folder name from .vstemplate filename by getting its parent folder -->
         <_TemplateFolderName>%(_DiscoveredProjectTemplateFiles.Filename)</_TemplateFolderName>
       </VsixProjectTemplate>
     </ItemGroup>
@@ -40,173 +37,105 @@
         <_TemplateFolderName>%(_DiscoveredItemTemplateFiles.Filename)</_TemplateFolderName>
       </VsixItemTemplate>
     </ItemGroup>
-  </Target>
 
-  <!--
-    Exclude template source files from being included as Content in the VSIX.
-    Templates are zipped separately; we don't want loose files.
-  -->
-  <PropertyGroup>
-    <DefaultItemExcludes>$(DefaultItemExcludes);$(VsixProjectTemplatesFolder)\**</DefaultItemExcludes>
-    <DefaultItemExcludes>$(DefaultItemExcludes);$(VsixItemTemplatesFolder)\**</DefaultItemExcludes>
-  </PropertyGroup>
+    <!--
+      Include all files from discovered template folders in the VSIX.
+      Templates are added as folders (not zipped) for VSSDK compatibility.
+    -->
+    <ItemGroup Condition="'@(_DiscoveredProjectTemplateFiles)' != ''">
+      <_ProjectTemplateFiles Include="$(MSBuildProjectDirectory)\$(VsixProjectTemplatesFolder)\**\*" />
+      <Content Include="@(_ProjectTemplateFiles)">
+        <IncludeInVSIX>true</IncludeInVSIX>
+        <VSIXSubPath>$(VsixProjectTemplatesFolder)\%(RecursiveDir)</VSIXSubPath>
+        <CopyToOutputDirectory>Never</CopyToOutputDirectory>
+      </Content>
+    </ItemGroup>
+
+    <ItemGroup Condition="'@(_DiscoveredItemTemplateFiles)' != ''">
+      <_ItemTemplateFiles Include="$(MSBuildProjectDirectory)\$(VsixItemTemplatesFolder)\**\*" />
+      <Content Include="@(_ItemTemplateFiles)">
+        <IncludeInVSIX>true</IncludeInVSIX>
+        <VSIXSubPath>$(VsixItemTemplatesFolder)\%(RecursiveDir)</VSIXSubPath>
+        <CopyToOutputDirectory>Never</CopyToOutputDirectory>
+      </Content>
+    </ItemGroup>
+  </Target>
 
   <!--
-    Target: PrepareVsixTemplates
-    Prepares template items for zipping by computing output paths.
+    Target: PrepareVsixTemplateReferences
+    Computes paths for template references from other projects.
   -->
-  <Target Name="PrepareVsixTemplates" BeforeTargets="ZipVsixTemplates" DependsOnTargets="DiscoverVsixTemplates">
+  <Target Name="PrepareVsixTemplateReferences"
+          BeforeTargets="CopyVsixTemplateReferences"
+          Condition="'@(VsixTemplateReference)' != ''">
     <ItemGroup>
-      <!-- Compute zip file name and output path for project templates -->
-      <!-- _TemplateFolderName was set during discovery from the .vstemplate filename -->
-      <VsixProjectTemplate>
-        <_ZipFileName>%(VsixProjectTemplate._TemplateFolderName).zip</_ZipFileName>
-        <_ZipOutputPath>$(_VsixTemplateIntermediateOutputPath)ProjectTemplates\%(VsixProjectTemplate.TargetSubPath)</_ZipOutputPath>
-      </VsixProjectTemplate>
-
-      <!-- Compute zip file name and output path for item templates -->
-      <VsixItemTemplate>
-        <_ZipFileName>%(VsixItemTemplate._TemplateFolderName).zip</_ZipFileName>
-        <_ZipOutputPath>$(_VsixTemplateIntermediateOutputPath)ItemTemplates\%(VsixItemTemplate.TargetSubPath)</_ZipOutputPath>
-      </VsixItemTemplate>
-
-      <!-- Compute paths for template references - Step 1: Get directory and folder name -->
+      <!-- Step 1: Get the directory of the referenced project -->
       <VsixTemplateReference>
         <_ReferencedProjectDir>$([System.IO.Path]::GetDirectoryName('%(Identity)'))</_ReferencedProjectDir>
         <_TemplateFolderName>$([System.IO.Path]::GetFileName('%(VsixTemplateReference.TemplatePath)'))</_TemplateFolderName>
       </VsixTemplateReference>
     </ItemGroup>
 
-    <!-- Step 2: Compute full path and zip info using metadata from Step 1 -->
+    <!-- Step 2: Compute full source path -->
     <ItemGroup>
       <VsixTemplateReference>
         <_FullTemplatePath>%(VsixTemplateReference._ReferencedProjectDir)\%(VsixTemplateReference.TemplatePath)</_FullTemplatePath>
-        <_ZipFileName>%(VsixTemplateReference._TemplateFolderName).zip</_ZipFileName>
-        <_ZipOutputPath Condition="'%(VsixTemplateReference.TemplateType)' == 'Project'">$(_VsixTemplateIntermediateOutputPath)ProjectTemplates\%(VsixTemplateReference.TargetSubPath)</_ZipOutputPath>
-        <_ZipOutputPath Condition="'%(VsixTemplateReference.TemplateType)' == 'Item'">$(_VsixTemplateIntermediateOutputPath)ItemTemplates\%(VsixTemplateReference.TargetSubPath)</_ZipOutputPath>
+        <_TargetFolder Condition="'%(VsixTemplateReference.TemplateType)' == 'Project'">$(MSBuildProjectDirectory)\$(VsixProjectTemplatesFolder)\%(VsixTemplateReference._TemplateFolderName)</_TargetFolder>
+        <_TargetFolder Condition="'%(VsixTemplateReference.TemplateType)' == 'Item'">$(MSBuildProjectDirectory)\$(VsixItemTemplatesFolder)\%(VsixTemplateReference._TemplateFolderName)</_TargetFolder>
       </VsixTemplateReference>
     </ItemGroup>
   </Target>
 
   <!--
-    Target: ZipVsixTemplates
-    Creates zip files from template folders.
+    Target: CopyVsixTemplateReferences
+    Copies template folders from referenced projects to the local template folders.
+    VSSDK will then discover and package them based on manifest Content entries.
   -->
-  <Target Name="ZipVsixTemplates"
+  <Target Name="CopyVsixTemplateReferences"
           BeforeTargets="GetVsixSourceItems"
-          DependsOnTargets="PrepareVsixTemplates"
-          Condition="'@(VsixProjectTemplate)' != '' or '@(VsixItemTemplate)' != '' or '@(VsixTemplateReference)' != ''">
-
-    <!-- Create intermediate output directories -->
-    <MakeDir Directories="$(_VsixTemplateIntermediateOutputPath)ProjectTemplates"
-             Condition="'@(VsixProjectTemplate)' != '' or ('@(VsixTemplateReference)' != '' and '@(VsixTemplateReference->WithMetadataValue('TemplateType', 'Project'))' != '')" />
-    <MakeDir Directories="$(_VsixTemplateIntermediateOutputPath)ItemTemplates"
-             Condition="'@(VsixItemTemplate)' != '' or ('@(VsixTemplateReference)' != '' and '@(VsixTemplateReference->WithMetadataValue('TemplateType', 'Item'))' != '')" />
-
-    <!-- Zip each project template folder -->
-    <ZipDirectory SourceDirectory="%(VsixProjectTemplate.Identity)"
-                  DestinationFile="%(VsixProjectTemplate._ZipOutputPath)%(VsixProjectTemplate._ZipFileName)"
-                  Overwrite="true"
-                  Condition="'@(VsixProjectTemplate)' != ''" />
-
-    <!-- Zip each item template folder -->
-    <ZipDirectory SourceDirectory="%(VsixItemTemplate.Identity)"
-                  DestinationFile="%(VsixItemTemplate._ZipOutputPath)%(VsixItemTemplate._ZipFileName)"
-                  Overwrite="true"
-                  Condition="'@(VsixItemTemplate)' != ''" />
-
-    <!-- Zip each template reference -->
-    <ZipDirectory SourceDirectory="%(VsixTemplateReference._FullTemplatePath)"
-                  DestinationFile="%(VsixTemplateReference._ZipOutputPath)%(VsixTemplateReference._ZipFileName)"
-                  Overwrite="true"
-                  Condition="'@(VsixTemplateReference)' != '' and '%(VsixTemplateReference.TemplateType)' != ''" />
+          DependsOnTargets="PrepareVsixTemplateReferences"
+          Condition="'@(VsixTemplateReference)' != ''">
 
-    <Message Importance="normal"
-             Text="Zipped project template: %(VsixProjectTemplate._TemplateFolderName)"
-             Condition="'@(VsixProjectTemplate)' != ''" />
+    <!-- Copy each template reference to the appropriate template folder -->
+    <ItemGroup Condition="'@(VsixTemplateReference)' != ''">
+      <_TemplateFilesToCopy Include="%(VsixTemplateReference._FullTemplatePath)\**\*">
+        <_DestinationFolder>%(VsixTemplateReference._TargetFolder)</_DestinationFolder>
+        <_SourceFolder>%(VsixTemplateReference._FullTemplatePath)</_SourceFolder>
+        <_VsixSubPathBase Condition="'%(VsixTemplateReference.TemplateType)' == 'Project'">$(VsixProjectTemplatesFolder)\%(VsixTemplateReference._TemplateFolderName)</_VsixSubPathBase>
+        <_VsixSubPathBase Condition="'%(VsixTemplateReference.TemplateType)' == 'Item'">$(VsixItemTemplatesFolder)\%(VsixTemplateReference._TemplateFolderName)</_VsixSubPathBase>
+      </_TemplateFilesToCopy>
+    </ItemGroup>
 
-    <Message Importance="normal"
-             Text="Zipped item template: %(VsixItemTemplate._TemplateFolderName)"
-             Condition="'@(VsixItemTemplate)' != ''" />
+    <Copy SourceFiles="@(_TemplateFilesToCopy)"
+          DestinationFiles="@(_TemplateFilesToCopy->'%(_DestinationFolder)\%(RecursiveDir)%(Filename)%(Extension)')"
+          SkipUnchangedFiles="true"
+          Condition="'@(_TemplateFilesToCopy)' != ''" />
+
+    <!--
+      Add copied files as Content items so VSSDK includes them in the VSIX.
+      VSSDK evaluates file globs at evaluation time, but we copy during target execution,
+      so we need to explicitly add these files for VSSDK to discover them.
+      Set VSIXSubPath to place files at the correct relative path in the VSIX.
+    -->
+    <ItemGroup Condition="'@(_TemplateFilesToCopy)' != ''">
+      <Content Include="@(_TemplateFilesToCopy->'%(_DestinationFolder)\%(RecursiveDir)%(Filename)%(Extension)')">
+        <IncludeInVSIX>true</IncludeInVSIX>
+        <VSIXSubPath>%(_VsixSubPathBase)\%(RecursiveDir)</VSIXSubPath>
+        <CopyToOutputDirectory>Never</CopyToOutputDirectory>
+      </Content>
+    </ItemGroup>
 
     <Message Importance="normal"
-             Text="Zipped template reference: %(VsixTemplateReference._TemplateFolderName) from %(VsixTemplateReference.Identity)"
+             Text="Copied template reference: %(VsixTemplateReference._TemplateFolderName) from %(VsixTemplateReference._FullTemplatePath)"
              Condition="'@(VsixTemplateReference)' != ''" />
   </Target>
 
-  <!--
-    Target: AddVsixTemplateSourceItems
-    Adds zipped templates to VSIXSourceItem for inclusion in the VSIX.
-  -->
-  <Target Name="AddVsixTemplateSourceItems"
-          BeforeTargets="GetVsixSourceItems"
-          AfterTargets="ZipVsixTemplates"
-          DependsOnTargets="ZipVsixTemplates">
-
-    <ItemGroup>
-      <!-- Add zipped project templates -->
-      <VSIXSourceItem Include="%(VsixProjectTemplate._ZipOutputPath)%(VsixProjectTemplate._ZipFileName)"
-                      Condition="'@(VsixProjectTemplate)' != ''">
-        <VSIXSubPath>ProjectTemplates\%(VsixProjectTemplate.TargetSubPath)</VSIXSubPath>
-        <Ngen>false</Ngen>
-      </VSIXSourceItem>
-
-      <!-- Add zipped item templates -->
-      <VSIXSourceItem Include="%(VsixItemTemplate._ZipOutputPath)%(VsixItemTemplate._ZipFileName)"
-                      Condition="'@(VsixItemTemplate)' != ''">
-        <VSIXSubPath>ItemTemplates\%(VsixItemTemplate.TargetSubPath)</VSIXSubPath>
-        <Ngen>false</Ngen>
-      </VSIXSourceItem>
-
-      <!-- Add pre-built template zips (project templates) -->
-      <VSIXSourceItem Include="%(VsixTemplateZip.Identity)"
-                      Condition="'@(VsixTemplateZip)' != '' and '%(VsixTemplateZip.TemplateType)' == 'Project'">
-        <VSIXSubPath>ProjectTemplates\%(VsixTemplateZip.TargetSubPath)</VSIXSubPath>
-        <Ngen>false</Ngen>
-      </VSIXSourceItem>
-
-      <!-- Add pre-built template zips (item templates) -->
-      <VSIXSourceItem Include="%(VsixTemplateZip.Identity)"
-                      Condition="'@(VsixTemplateZip)' != '' and '%(VsixTemplateZip.TemplateType)' == 'Item'">
-        <VSIXSubPath>ItemTemplates\%(VsixTemplateZip.TargetSubPath)</VSIXSubPath>
-        <Ngen>false</Ngen>
-      </VSIXSourceItem>
-
-      <!-- Add template references (project templates) -->
-      <VSIXSourceItem Include="%(VsixTemplateReference._ZipOutputPath)%(VsixTemplateReference._ZipFileName)"
-                      Condition="'@(VsixTemplateReference)' != '' and '%(VsixTemplateReference.TemplateType)' == 'Project'">
-        <VSIXSubPath>ProjectTemplates\%(VsixTemplateReference.TargetSubPath)</VSIXSubPath>
-        <Ngen>false</Ngen>
-      </VSIXSourceItem>
-
-      <!-- Add template references (item templates) -->
-      <VSIXSourceItem Include="%(VsixTemplateReference._ZipOutputPath)%(VsixTemplateReference._ZipFileName)"
-                      Condition="'@(VsixTemplateReference)' != '' and '%(VsixTemplateReference.TemplateType)' == 'Item'">
-        <VSIXSubPath>ItemTemplates\%(VsixTemplateReference.TargetSubPath)</VSIXSubPath>
-        <Ngen>false</Ngen>
-      </VSIXSourceItem>
-    </ItemGroup>
-  </Target>
-
-  <!--
-    Target: ValidateVsixTemplateZipItems
-    Warns if VsixTemplateZip items don't specify a TemplateType.
-  -->
-  <Target Name="ValidateVsixTemplateZipItems"
-          BeforeTargets="GetVsixSourceItems"
-          Condition="'@(VsixTemplateZip)' != ''">
-
-    <Warning Code="VSIXSDK010"
-             Text="VsixTemplateZip item '%(VsixTemplateZip.Identity)' does not specify TemplateType. Set TemplateType to 'Project' or 'Item'."
-             Condition="'%(VsixTemplateZip.TemplateType)' == ''" />
-  </Target>
-
   <!--
     Target: ValidateVsixTemplateReferenceItems
     Warns if VsixTemplateReference items are missing required metadata.
   -->
   <Target Name="ValidateVsixTemplateReferenceItems"
-          BeforeTargets="GetVsixSourceItems"
+          BeforeTargets="PrepareVsixTemplateReferences"
           Condition="'@(VsixTemplateReference)' != ''">
 
     <Warning Code="VSIXSDK013"
@@ -220,11 +149,11 @@
 
   <!--
     Target: WarnMissingManifestContent
-    Warns if templates are defined but the manifest might not have Content entries.
-    This is a reminder since the manifest must declare template content for VS to find them.
+    Warns if templates are discovered but the manifest doesn't have Content entries.
+    VSSDK requires these entries to properly package and register templates.
   -->
   <Target Name="WarnMissingManifestContent"
-          AfterTargets="ZipVsixTemplates"
+          AfterTargets="DiscoverVsixTemplates;CopyVsixTemplateReferences"
           Condition="('@(VsixProjectTemplate)' != '' or '@(VsixItemTemplate)' != '' or '@(VsixTemplateReference)' != '') and '$(_SourceVsixManifestPath)' != ''">
 
     <!-- Determine if we have any project or item templates -->
@@ -257,12 +186,4 @@
              Condition="'$(_HasItemTemplates)' == 'true' and '@(_ManifestItemTemplates)' == ''" />
   </Target>
 
-  <!--
-    Target: CleanVsixTemplates
-    Cleans up intermediate template files.
-  -->
-  <Target Name="CleanVsixTemplates" AfterTargets="Clean">
-    <RemoveDir Directories="$(_VsixTemplateIntermediateOutputPath)" />
-  </Target>
-
 </Project>
diff --git a/tests/e2e/E2E.AllFeatures/E2E.AllFeatures.csproj b/tests/e2e/E2E.AllFeatures/E2E.AllFeatures.csproj
index 9956861..f87baeb 100644
--- a/tests/e2e/E2E.AllFeatures/E2E.AllFeatures.csproj
+++ b/tests/e2e/E2E.AllFeatures/E2E.AllFeatures.csproj
@@ -11,18 +11,13 @@
   <PropertyGroup>
     <Version>1.0.0</Version>
     <!-- Exclude template source folders from compilation -->
-    <DefaultItemExcludes>$(DefaultItemExcludes);PreBuiltSource\**;ManualTemplates\**</DefaultItemExcludes>
+    <DefaultItemExcludes>$(DefaultItemExcludes);ManualTemplates\**</DefaultItemExcludes>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.*" />
   </ItemGroup>
 
-  <!-- Pre-built template zip -->
-  <ItemGroup>
-    <VsixTemplateZip Include="PreBuilt\PreBuilt.zip" TemplateType="Project" />
-  </ItemGroup>
-
   <!-- Manual template with subpath -->
   <ItemGroup>
     <VsixProjectTemplate Include="ManualTemplates\ManualProject" TargetSubPath="Manual" />
@@ -33,13 +28,4 @@
     <PkgDefToMerge Include="CustomSettings.pkgdef" />
   </ItemGroup>
 
-  <!-- Target to create pre-built zip if needed -->
-  <Target Name="CreatePreBuiltZip" BeforeTargets="PrepareForBuild">
-    <MakeDir Directories="PreBuilt" Condition="!Exists('PreBuilt')" />
-    <ZipDirectory SourceDirectory="PreBuiltSource\PreBuiltProject"
-                  DestinationFile="PreBuilt\PreBuilt.zip"
-                  Overwrite="true"
-                  Condition="Exists('PreBuiltSource\PreBuiltProject') and !Exists('PreBuilt\PreBuilt.zip')" />
-  </Target>
-
 </Project>
diff --git a/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/Class1.cs b/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/Class1.cs
deleted file mode 100644
index 4fc708c..0000000
--- a/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/Class1.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace $safeprojectname$
-{
-    public class Class1 { }
-}
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/E2E.Templates.PreBuiltZip.csproj b/tests/e2e/E2E.Templates.PreBuiltZip/E2E.Templates.PreBuiltZip.csproj
deleted file mode 100644
index a77135c..0000000
--- a/tests/e2e/E2E.Templates.PreBuiltZip/E2E.Templates.PreBuiltZip.csproj
+++ /dev/null
@@ -1,46 +0,0 @@
-<!--
-  E2E.Templates.PreBuiltZip - Tests VsixTemplateZip with pre-built zip files.
-
-  Validates:
-  - Pre-built zips included in VSIX
-  - TemplateType metadata routes to correct folder
-  - Auto-discovery disabled works
--->
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <Version>1.0.0</Version>
-    <!-- Disable auto-discovery - we're using pre-built zips -->
-    <EnableDefaultVsixTemplateItems>false</EnableDefaultVsixTemplateItems>
-    <!-- Exclude template source files from compilation (they contain VS template placeholders) -->
-    <DefaultItemExcludes>$(DefaultItemExcludes);TemplateSource\**</DefaultItemExcludes>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.*" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <VsixTemplateZip Include="PreBuilt\PreBuiltProject.zip" TemplateType="Project" />
-    <VsixTemplateZip Include="PreBuilt\PreBuiltItem.zip" TemplateType="Item" />
-  </ItemGroup>
-
-  <!--
-    Target to create pre-built zips from source folders if they don't exist.
-    In a real scenario, these zips would already exist from another build process.
-  -->
-  <Target Name="CreatePreBuiltZips" BeforeTargets="PrepareForBuild">
-    <MakeDir Directories="PreBuilt" Condition="!Exists('PreBuilt')" />
-
-    <ZipDirectory SourceDirectory="TemplateSource\ProjectTemplate"
-                  DestinationFile="PreBuilt\PreBuiltProject.zip"
-                  Overwrite="true"
-                  Condition="Exists('TemplateSource\ProjectTemplate') and !Exists('PreBuilt\PreBuiltProject.zip')" />
-
-    <ZipDirectory SourceDirectory="TemplateSource\ItemTemplate"
-                  DestinationFile="PreBuilt\PreBuiltItem.zip"
-                  Overwrite="true"
-                  Condition="Exists('TemplateSource\ItemTemplate') and !Exists('PreBuilt\PreBuiltItem.zip')" />
-  </Target>
-
-</Project>
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/E2ETemplatesPreBuiltZipPackage.cs b/tests/e2e/E2E.Templates.PreBuiltZip/E2ETemplatesPreBuiltZipPackage.cs
deleted file mode 100644
index 2df0cb9..0000000
--- a/tests/e2e/E2E.Templates.PreBuiltZip/E2ETemplatesPreBuiltZipPackage.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using System.Threading;
-using Microsoft.VisualStudio.Shell;
-using Task = System.Threading.Tasks.Task;
-
-namespace E2E.Templates.PreBuiltZip
-{
-    [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
-    [Guid("00000000-0000-0000-0000-00000000000A")]
-    public sealed class E2ETemplatesPreBuiltZipPackage : AsyncPackage
-    {
-        protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
-        {
-            await base.InitializeAsync(cancellationToken, progress);
-            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-        }
-    }
-}
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ItemTemplate/PreBuiltItem.vstemplate b/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ItemTemplate/PreBuiltItem.vstemplate
deleted file mode 100644
index 055f055..0000000
--- a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ItemTemplate/PreBuiltItem.vstemplate
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<VSTemplate Version="3.0.0" Type="Item" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
-  <TemplateData>
-    <Name>Pre-Built Item</Name>
-    <Description>An item template from a pre-built zip</Description>
-    <ProjectType>CSharp</ProjectType>
-    <SortOrder>10</SortOrder>
-    <DefaultName>PreBuiltItem.cs</DefaultName>
-  </TemplateData>
-  <TemplateContent>
-    <ProjectItem ReplaceParameters="true" TargetFileName="$fileinputname$.cs">Item.cs</ProjectItem>
-  </TemplateContent>
-</VSTemplate>
diff --git a/tests/e2e/E2E.Templates.Reference/E2E.Templates.Reference.csproj b/tests/e2e/E2E.Templates.Reference/E2E.Templates.Reference.csproj
new file mode 100644
index 0000000..c5fe1b2
--- /dev/null
+++ b/tests/e2e/E2E.Templates.Reference/E2E.Templates.Reference.csproj
@@ -0,0 +1,32 @@
+<!--
+  E2E.Templates.Reference - Tests VsixTemplateReference for cross-project templates.
+
+  Validates:
+  - VsixTemplateReference copies project templates from referenced projects
+  - VsixTemplateReference copies item templates from referenced projects
+  - Templates are properly included in VSIX via VSSDK
+  - Auto-injection of Content entries into manifest
+-->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Version>1.0.0</Version>
+    <!-- Exclude shared template folder from compilation (contains VS placeholders) -->
+    <DefaultItemExcludes>$(DefaultItemExcludes);SharedTemplates\**</DefaultItemExcludes>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.*" />
+  </ItemGroup>
+
+  <!-- Reference templates from the SharedTemplates project -->
+  <ItemGroup>
+    <VsixTemplateReference Include="SharedTemplates\SharedTemplates.csproj"
+                           TemplateType="Project"
+                           TemplatePath="ProjectTemplate" />
+    <VsixTemplateReference Include="SharedTemplates\SharedTemplates.csproj"
+                           TemplateType="Item"
+                           TemplatePath="ItemTemplate" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/e2e/E2E.Templates.Reference/E2ETemplatesReferencePackage.cs b/tests/e2e/E2E.Templates.Reference/E2ETemplatesReferencePackage.cs
new file mode 100644
index 0000000..fcc6111
--- /dev/null
+++ b/tests/e2e/E2E.Templates.Reference/E2ETemplatesReferencePackage.cs
@@ -0,0 +1,11 @@
+using Microsoft.VisualStudio.Shell;
+using System.Runtime.InteropServices;
+
+namespace E2E.Templates.Reference
+{
+    [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
+    [Guid("00000000-0000-0000-0000-000000000020")]
+    public sealed class E2ETemplatesReferencePackage : AsyncPackage
+    {
+    }
+}
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ItemTemplate/Item.cs b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ItemTemplate/Item.cs
similarity index 60%
rename from tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ItemTemplate/Item.cs
rename to tests/e2e/E2E.Templates.Reference/SharedTemplates/ItemTemplate/Item.cs
index 3889610..2adf76c 100644
--- a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ItemTemplate/Item.cs
+++ b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ItemTemplate/Item.cs
@@ -2,6 +2,5 @@ namespace $rootnamespace$
 {
     public class $safeitemname$
     {
-        // Created from pre-built item template
     }
 }
diff --git a/tests/e2e/E2E.Templates.Reference/SharedTemplates/ItemTemplate/RefItem.vstemplate b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ItemTemplate/RefItem.vstemplate
new file mode 100644
index 0000000..63ddd28
--- /dev/null
+++ b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ItemTemplate/RefItem.vstemplate
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<VSTemplate Version="3.0.0" Type="Item" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
+  <TemplateData>
+    <Name>Referenced Item Template</Name>
+    <Description>An item template from a referenced project</Description>
+    <ProjectType>CSharp</ProjectType>
+    <DefaultName>RefItem</DefaultName>
+  </TemplateData>
+  <TemplateContent>
+    <ProjectItem ReplaceParameters="true">Item.cs</ProjectItem>
+  </TemplateContent>
+</VSTemplate>
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/Class1.cs b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/Class1.cs
similarity index 100%
rename from tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/Class1.cs
rename to tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/Class1.cs
diff --git a/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/Project.csproj b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/Project.csproj
similarity index 70%
rename from tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/Project.csproj
rename to tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/Project.csproj
index ec2cce1..d54876d 100644
--- a/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/Project.csproj
+++ b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/Project.csproj
@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>$safeprojectname$</RootNamespace>
   </PropertyGroup>
 </Project>
diff --git a/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/PreBuiltProject.vstemplate b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/RefProject.vstemplate
similarity index 74%
rename from tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/PreBuiltProject.vstemplate
rename to tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/RefProject.vstemplate
index 8b424ad..5d2fb04 100644
--- a/tests/e2e/E2E.AllFeatures/PreBuiltSource/PreBuiltProject/PreBuiltProject.vstemplate
+++ b/tests/e2e/E2E.Templates.Reference/SharedTemplates/ProjectTemplate/RefProject.vstemplate
@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <VSTemplate Version="3.0.0" Type="Project" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
   <TemplateData>
-    <Name>Pre-Built Project</Name>
-    <Description>Pre-built zip template in AllFeatures</Description>
+    <Name>Referenced Project Template</Name>
+    <Description>A project template from a referenced project</Description>
     <ProjectType>CSharp</ProjectType>
-    <DefaultName>PreBuiltProject</DefaultName>
+    <DefaultName>RefProject</DefaultName>
     <ProvideDefaultName>true</ProvideDefaultName>
   </TemplateData>
   <TemplateContent>
diff --git a/tests/e2e/E2E.Templates.Reference/SharedTemplates/SharedTemplates.csproj b/tests/e2e/E2E.Templates.Reference/SharedTemplates/SharedTemplates.csproj
new file mode 100644
index 0000000..23d6163
--- /dev/null
+++ b/tests/e2e/E2E.Templates.Reference/SharedTemplates/SharedTemplates.csproj
@@ -0,0 +1,18 @@
+<!--
+  SharedTemplates - A library project containing templates to be referenced.
+  This simulates an SDK-style project that the VSIX Manifest Designer cannot enumerate.
+-->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <!-- This project exists only to hold templates, no code output needed -->
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+  </PropertyGroup>
+
+  <!-- Exclude template files from compilation (they contain VS placeholders) -->
+  <PropertyGroup>
+    <DefaultItemExcludes>$(DefaultItemExcludes);ProjectTemplate\**;ItemTemplate\**</DefaultItemExcludes>
+  </PropertyGroup>
+
+</Project>
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/source.extension.vsixmanifest b/tests/e2e/E2E.Templates.Reference/source.extension.vsixmanifest
similarity index 73%
rename from tests/e2e/E2E.Templates.PreBuiltZip/source.extension.vsixmanifest
rename to tests/e2e/E2E.Templates.Reference/source.extension.vsixmanifest
index 302eb62..ab6f4d1 100644
--- a/tests/e2e/E2E.Templates.PreBuiltZip/source.extension.vsixmanifest
+++ b/tests/e2e/E2E.Templates.Reference/source.extension.vsixmanifest
@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
   <Metadata>
-    <Identity Id="E2E.Templates.PreBuiltZip.00000000-0000-0000-0000-00000000000A" Version="1.0.0" Language="en-US" Publisher="E2E Tests" />
-    <DisplayName>E2E Templates PreBuiltZip Test</DisplayName>
-    <Description xml:space="preserve">E2E test for VsixTemplateZip with pre-built zip files</Description>
+    <Identity Id="E2E.Templates.Reference.00000000-0000-0000-0000-000000000020" Version="1.0.0" Language="en-US" Publisher="E2E Tests" />
+    <DisplayName>E2E Templates Reference Test</DisplayName>
+    <Description xml:space="preserve">E2E test for VsixTemplateReference - cross-project template references</Description>
   </Metadata>
   <Installation>
     <InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[17.0, 19.0)">
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/E2E.Templates.ReferenceManual.csproj b/tests/e2e/E2E.Templates.ReferenceManual/E2E.Templates.ReferenceManual.csproj
new file mode 100644
index 0000000..e4fcbdb
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/E2E.Templates.ReferenceManual.csproj
@@ -0,0 +1,31 @@
+<!--
+  E2E.Templates.ReferenceManual - Tests VsixTemplateReference with manual manifest configuration.
+
+  Validates:
+  - VsixTemplateReference works when AutoInjectVsixTemplateContent=false
+  - Manual Content entries in manifest are respected
+  - Templates are properly included in VSIX via VSSDK
+-->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Version>1.0.0</Version>
+    <!-- Exclude shared template folder from compilation (contains VS placeholders) -->
+    <DefaultItemExcludes>$(DefaultItemExcludes);SharedTemplates\**</DefaultItemExcludes>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.*" />
+  </ItemGroup>
+
+  <!-- Reference templates from the SharedTemplates project -->
+  <ItemGroup>
+    <VsixTemplateReference Include="SharedTemplates\SharedTemplates.csproj"
+                           TemplateType="Project"
+                           TemplatePath="ProjectTemplate" />
+    <VsixTemplateReference Include="SharedTemplates\SharedTemplates.csproj"
+                           TemplateType="Item"
+                           TemplatePath="ItemTemplate" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/E2ETemplatesReferenceManualPackage.cs b/tests/e2e/E2E.Templates.ReferenceManual/E2ETemplatesReferenceManualPackage.cs
new file mode 100644
index 0000000..3d96142
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/E2ETemplatesReferenceManualPackage.cs
@@ -0,0 +1,11 @@
+using Microsoft.VisualStudio.Shell;
+using System.Runtime.InteropServices;
+
+namespace E2E.Templates.ReferenceManual
+{
+    [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
+    [Guid("00000000-0000-0000-0000-000000000021")]
+    public sealed class E2ETemplatesReferenceManualPackage : AsyncPackage
+    {
+    }
+}
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ItemTemplate/Item.cs b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ItemTemplate/Item.cs
new file mode 100644
index 0000000..2adf76c
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ItemTemplate/Item.cs
@@ -0,0 +1,6 @@
+namespace $rootnamespace$
+{
+    public class $safeitemname$
+    {
+    }
+}
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ItemTemplate/RefItem.vstemplate b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ItemTemplate/RefItem.vstemplate
new file mode 100644
index 0000000..2e14a7c
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ItemTemplate/RefItem.vstemplate
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<VSTemplate Version="3.0.0" Type="Item" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
+  <TemplateData>
+    <Name>Referenced Item Template (Manual)</Name>
+    <Description>An item template from a referenced project (manual manifest)</Description>
+    <ProjectType>CSharp</ProjectType>
+    <DefaultName>RefItem</DefaultName>
+  </TemplateData>
+  <TemplateContent>
+    <ProjectItem ReplaceParameters="true">Item.cs</ProjectItem>
+  </TemplateContent>
+</VSTemplate>
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/Class1.cs b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/Class1.cs
new file mode 100644
index 0000000..468679e
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/Class1.cs
@@ -0,0 +1,6 @@
+namespace $safeprojectname$
+{
+    public class Class1
+    {
+    }
+}
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/Project.csproj b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/Project.csproj
similarity index 62%
rename from tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/Project.csproj
rename to tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/Project.csproj
index e8cd599..d54876d 100644
--- a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/Project.csproj
+++ b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/Project.csproj
@@ -1,7 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <RootNamespace>$safeprojectname$</RootNamespace>
   </PropertyGroup>
 </Project>
diff --git a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/PreBuiltProject.vstemplate b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/RefProject.vstemplate
similarity index 54%
rename from tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/PreBuiltProject.vstemplate
rename to tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/RefProject.vstemplate
index 6c17dd0..70b00c5 100644
--- a/tests/e2e/E2E.Templates.PreBuiltZip/TemplateSource/ProjectTemplate/PreBuiltProject.vstemplate
+++ b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/ProjectTemplate/RefProject.vstemplate
@@ -1,17 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
 <VSTemplate Version="3.0.0" Type="Project" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
   <TemplateData>
-    <Name>Pre-Built Project Template</Name>
-    <Description>A project template from a pre-built zip</Description>
+    <Name>Referenced Project Template (Manual)</Name>
+    <Description>A project template from a referenced project (manual manifest)</Description>
     <ProjectType>CSharp</ProjectType>
-    <SortOrder>1000</SortOrder>
-    <DefaultName>PreBuiltProject</DefaultName>
+    <DefaultName>RefProject</DefaultName>
     <ProvideDefaultName>true</ProvideDefaultName>
-    <CreateNewFolder>true</CreateNewFolder>
   </TemplateData>
   <TemplateContent>
     <Project File="Project.csproj" ReplaceParameters="true">
-      <ProjectItem ReplaceParameters="true" TargetFileName="Class1.cs">Class1.cs</ProjectItem>
+      <ProjectItem ReplaceParameters="true">Class1.cs</ProjectItem>
     </Project>
   </TemplateContent>
 </VSTemplate>
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/SharedTemplates.csproj b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/SharedTemplates.csproj
new file mode 100644
index 0000000..23d6163
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/SharedTemplates/SharedTemplates.csproj
@@ -0,0 +1,18 @@
+<!--
+  SharedTemplates - A library project containing templates to be referenced.
+  This simulates an SDK-style project that the VSIX Manifest Designer cannot enumerate.
+-->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <!-- This project exists only to hold templates, no code output needed -->
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+  </PropertyGroup>
+
+  <!-- Exclude template files from compilation (they contain VS placeholders) -->
+  <PropertyGroup>
+    <DefaultItemExcludes>$(DefaultItemExcludes);ProjectTemplate\**;ItemTemplate\**</DefaultItemExcludes>
+  </PropertyGroup>
+
+</Project>
diff --git a/tests/e2e/E2E.Templates.ReferenceManual/source.extension.vsixmanifest b/tests/e2e/E2E.Templates.ReferenceManual/source.extension.vsixmanifest
new file mode 100644
index 0000000..3ca269e
--- /dev/null
+++ b/tests/e2e/E2E.Templates.ReferenceManual/source.extension.vsixmanifest
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
+  <Metadata>
+    <Identity Id="E2E.Templates.ReferenceManual.00000000-0000-0000-0000-000000000021" Version="1.0.0" Language="en-US" Publisher="E2E Tests" />
+    <DisplayName>E2E Templates Reference Manual Test</DisplayName>
+    <Description xml:space="preserve">E2E test for VsixTemplateReference with manual manifest Content entries</Description>
+  </Metadata>
+  <Installation>
+    <InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[17.0, 19.0)">
+      <ProductArchitecture>amd64</ProductArchitecture>
+    </InstallationTarget>
+  </Installation>
+  <Dependencies>
+    <Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="[4.7.2,)" />
+  </Dependencies>
+  <Prerequisites>
+    <Prerequisite Id="Microsoft.VisualStudio.Component.CoreEditor" Version="[17.0,19.0)" DisplayName="Visual Studio core editor" />
+  </Prerequisites>
+  <!-- Manual Content entries (auto-inject is disabled for this test) -->
+  <Content>
+    <ProjectTemplate Path="ProjectTemplates" />
+    <ItemTemplate Path="ItemTemplates" />
+  </Content>
+</PackageManifest>