• Revenue-focused: Maximize ad revenue and impression opportunities
• UX-focused: Prioritize gameplay flow and user satisfaction
• Balanced: Optimize for both revenue and UX
• Not sure yet: Default to Balanced and proceed. At Step 8, briefly note you're using Balanced since they were unsure, and invite them to indicate a different preference now that they've seen the format options.

1. Open Unity → Window > Package Manager
2. Select Unity Registry dropdown or Services tab
3. Search for "Ads Mediation" package
4. Review package description to confirm it's the LevelPlay SDK
5. Click Install button
6. Wait for package to download and import

references/ios-setup.md

• With newer versions of Mobile Dependency Resolver (shipped with the Ads Mediation package): Dependencies auto-resolve on build (no manual action needed). If unsure, try building first — if it fails, manually resolve via the Android Resolver menu.
• With older MDR or other managers: Go to Assets > [Your Dependency Manager] > Android Resolver > Resolve
• Example paths:
  • MDR:

    Assets > Mobile Dependency Resolver > Android Resolver > Resolve

  • EDM4U:

    Assets > External Dependency Manager > Android Resolver > Resolve

• Menu paths may vary depending on dependency manager version. Look for 'Android Resolver' under your dependency manager's menu.

• All dependency managers require manual CocoaPods installation:
  • MDR:

    Assets > Mobile Dependency Resolver > iOS Resolver > Install Cocoapods

  • EDM4U:

    Assets > External Dependency Manager > iOS Resolver > Install Cocoapods

  • UEDM: Similar path under Unity External Dependency Manager

1. Click Import on the prompt to install Mobile Dependency Resolver
2. After installation:
   • Android: Dependencies will auto-resolve on build (newer MDR versions)
   • iOS: Go to Assets > Mobile Dependency Resolver > iOS Resolver > Install Cocoapods

• Android: Gradle dependencies in

  Assets/Plugins/Android/

• iOS: Podfile references or CocoaPods installation confirmation in console

1. Go to Edit > Project Settings > Player
2. Select Android tab
3. Expand Publishing Settings
4. Under Build, check Custom Main Gradle Template

<uses-permission android:name="com.google.android.gms.permission.AD_ID"/>

• Add your app
• Create ad units

• Android App Key: AdMob Android app key
• iOS App Key: AdMob iOS app key

Note: This skill provides technical integration guidance, including for LevelPlay's privacy APIs. It is not legal advice, and it does not determine which laws apply to your app — that depends on your users, your data practices, and your distribution. Consult your own legal counsel, and refer to Regulation Advanced Settings for Unity for the authoritative LevelPlay documentation.

references/privacy-settings.md

using Unity.Services.LevelPlay;

// true = user has granted consent, false = user has not consented
LevelPlayPrivacySettings.SetGDPRConsent(true);

using Unity.Services.LevelPlay;
using System.Collections.Generic;

// Add an entry for each ad network you have installed
LevelPlayPrivacySettings.SetGDPRConsents(new Dictionary<string, bool> {
    { "UnityAds", true },
    { "IronSource", true }
    // See references/privacy-settings.md for the full network key list
});

using Unity.Services.LevelPlay;

LevelPlayPrivacySettings.SetCCPA(true); // User opted out of data sale

using Unity.Services.LevelPlay;

LevelPlayPrivacySettings.SetCOPPA(true); // Child-directed app

LevelPlay.Init()

references/privacy-settings.md

LevelPlay.Init()

references/ios-setup.md

• Step 3: Do you see the 'Ads Mediation' package in Unity Package Manager under 'Packages: In Project'?
• Step 4: Have you run dependency resolution for your target platform(s) without errors?
• Step 5: Do you have your App Key copied from the LevelPlay dashboard?
• Step 6 (only if using AdMob): Have you configured AdMob keys in Unity Editor settings?

• Missing Step 3: Code will show

  CS0246

  namespace errors → Direct to Step 3
• Missing Step 4: Code compiles but Android/iOS builds will fail → Direct to Step 4
• Missing Step 5: They won't have credentials to initialize → Direct to Step 5
• Do not provide C# code until they confirm all steps are complete

• Optional — Analytics: ILRD Wiring. Ask this question verbatim — do not summarize or rephrase it: "Do you use an analytics or attribution platform (Firebase, AppsFlyer, Adjust, Singular, or custom backend) that needs ad revenue data? If yes, the init script will include a logging stub for Impression Level Revenue (ILRD) — 3 lines of code, no analytics platform setup required yet. (Yes / No / Not sure — defaults to yes)" Record the answer.
• Proceed with initialization code.

1. Create a new dedicated script for LevelPlay initialization
2. Add to an existing initialization/manager script they already have
3. Create a new LevelPlay script that your existing manager calls
4. Just show me the initialization code — I'll decide how to integrate it

LevelPlayInitializer.cs

using UnityEngine;
using Unity.Services.LevelPlay;

public class LevelPlayInitializer : MonoBehaviour
{
    [SerializeField] private string appKey;

    void Awake()
    {
        // Persist across scene loads so ads stay initialized
        DontDestroyOnLoad(gameObject);
    }

    void Start()
    {
        // Register initialization callbacks
        LevelPlay.OnInitSuccess += OnInitSuccess;
        LevelPlay.OnInitFailed += OnInitFailed;

        // Initialize the SDK with your App Key
        LevelPlay.Init(appKey);
    }

    private void OnInitSuccess(LevelPlayConfiguration config)
    {
        Debug.Log("LevelPlay SDK initialized successfully");
        // SDK is now ready to load ads
    }

    private void OnInitFailed(LevelPlayInitError error)
    {
        Debug.LogError($"LevelPlay initialization failed: {error.ErrorMessage}");
    }

    void OnDestroy()
    {
        LevelPlay.OnInitSuccess -= OnInitSuccess;
        LevelPlay.OnInitFailed -= OnInitFailed;
    }
}

Assets/Scripts/LevelPlayInitializer.cs

Assets/Scripts/Ads/LevelPlayInitializer.cs

1. Attach script to a GameObject in your first scene
2. In Unity Inspector, find the "App Key" field
3. Paste your App Key from Step 5 into that field

Start()

LevelPlay.Init(appKey)

// MUST be registered BEFORE LevelPlay.Init() to avoid losing early impressions.
// Callback fires on a BACKGROUND thread — see references/ilrd-api.md for
// thread-safe forwarding patterns and a Firebase example.
LevelPlay.OnImpressionDataReady += OnImpressionDataReady;

private void OnImpressionDataReady(LevelPlayImpressionData impressionData)
{
    // See references/ilrd-api.md for full implementation.
    // For now, just log so you can verify it fires:
    Debug.Log($"ILRD: {impressionData.AdNetwork} / {impressionData.AdFormat} / ${impressionData.Revenue}");
}

OnDestroy()

LevelPlay.OnImpressionDataReady -= OnImpressionDataReady;

references/ilrd-api.md

LevelPlayInitializer.cs

• Always register

  OnInitSuccess

  and

  OnInitFailed

  callbacks before calling

  Init()

• Call initialization early in app lifecycle (in

  Awake()

  or

  Start()

  of first scene)
• Only initialize once. If initialization script is in first scene and you have multiple scenes, add

  DontDestroyOnLoad(gameObject);

  in

  Awake()

  to prevent re-initialization when loading new scenes
• Wait for

  OnInitSuccess

  before creating ad objects

references/initialization-api.md

• User focused on maximizing revenue, impressions, or monetization → Use Revenue-Focused Strategy
• User focused on user experience, retention, or avoiding annoyance → Use UX-Focused Strategy
• User wants to balance both or mentioned both revenue and UX → Use Balanced Strategy
• User answered "Not sure yet" in Step 2 → Use Balanced Strategy. After presenting the recommendation, add: "Since you weren't sure of your goal earlier, I've gone with the Balanced approach — if you'd prefer to lean more toward revenue or user experience now that you've seen the options, just say so."
• If unclear, ask: "Would you prioritize revenue, user experience, or a balance of both?"

• Rewarded ads: Primary monetization driver
  • Implement in multiple high-value moments
  • Use for premium rewards, extra lives, bonus content
  • Load ads proactively to ensure availability
• Interstitial ads: Secondary revenue source
  • Show at natural transition points (level complete, game over)
  • Frequency cap: Every 3-5 minutes of gameplay (see

    references/interstitial-api.md

    )
• Banner ads: Persistent revenue during gameplay
  • Show during core gameplay loops
  • Use smart positioning to avoid UI conflicts

• Rewarded ads: Primary and often only ad format
  • User-initiated only (explicit opt-in)
  • High-value rewards that feel generous
  • No forced ads, ever
• Interstitial ads: Optional, sparingly used
  • Only at major session boundaries (e.g., exiting to main menu)
  • Never interrupt active gameplay
• Banner ads: Generally avoided or minimized
  • If used, only during menu screens, not gameplay
  • Small, non-intrusive sizes

• Rewarded ads: Core monetization
  • 2-3 strategic placements in high-engagement moments
  • Rewards feel valuable but not exploitative
• Interstitial ads: Moderate usage
  • At natural breakpoints (level transitions, session ends)
  • Frequency cap: Every 5-7 minutes (see

    references/interstitial-api.md

    )
• Banner ads: Selective placement
  • Show in menus or low-attention moments
  • Hide during intense gameplay

• Did you complete SDK initialization in Step 7?
• Did you receive the 'LevelPlay SDK initialized successfully' log message in your Unity console?

• Direct back to Step 7 to complete initialization first
• Do not provide ad implementation code until initialization is confirmed working

1. Separate manager scripts for each ad format - Create individual scripts like

   RewardedAdManager.cs

   ,

   InterstitialAdManager.cs

   ,

   BannerAdManager.cs

   (good for larger projects, clear separation of concerns)
2. One unified AdManager script - Create a single

   AdManager.cs

   that handles all ad formats (simpler, everything in one place)
3. Just show me the code snippets - Provide implementation code without wrapping it in specific files, so you can integrate it however you prefer
4. I already have ad manager code - Review and help fix/update existing implementation

Config.Builder().SetBidFloor(...)

• Ask: "Please share your existing ad manager code for review"
• Wait for them to provide the code
• Analyze the existing implementation:
  • Check if they're using current LevelPlay Ad Unit API (LevelPlayRewardedAd, LevelPlayInterstitialAd, LevelPlayBannerAd)
  • Identify if they're using deprecated IronSource.Agent APIs
  • Check for proper callback registration/unsubscription
  • Look for missing error handling or memory leaks
• Provide specific guidance:
  • If using deprecated APIs: "You're using the old IronSource.Agent API. Here's how to migrate to the new LevelPlay Ad Unit API:"
  • If using current APIs with issues: "Your implementation looks good but I noticed [specific issues]. Here's how to fix them:"
  • If implementation is correct: "Your implementation looks solid. Which additional ad formats would you like to add?"
• Offer to either:
  • Provide fixes as code snippets to integrate into existing files
  • Suggest refactoring if the code has structural issues
• When adding new formats after reviewing existing code, present the bid floor prompt scoped to those new formats only, confirm whether to match their existing code organization pattern or use a new one, then follow the same implementation guidelines as Options 1–3 above.

• Rewarded ads: See

  references/rewarded-api.md

• Interstitial ads: See

  references/interstitial-api.md

• Banner ads: See

  references/banner-api.md

1. Load: Request an ad from LevelPlay
2. Listen: Register callbacks for ad events (loaded, failed, shown, clicked, closed)
3. Check readiness: Verify ad is ready before showing
4. Show: Display the ad to the user
5. Handle callbacks: Respond to user interactions and ad lifecycle events

• Create complete, production-ready

  .cs

  files for each ad format
• Name them clearly:

  RewardedAdManager.cs

  ,

  InterstitialAdManager.cs

  ,

  BannerAdManager.cs

• Include full class structure with proper namespaces
• Each manager handles one ad format completely

• Create a single

  AdManager.cs

  file
• Include methods and callbacks for all requested ad formats in one class
• Use clear method naming to distinguish between formats (e.g.,

  LoadRewardedAd()

  ,

  LoadInterstitial()

  )
• Keep code organized with regions or comments separating each ad format

• Provide focused code blocks without full class wrappers
• Clearly label each snippet (e.g., "Rewarded Ad Initialization", "Interstitial Event Callbacks")
• Explain where/how to integrate each snippet
• Note any dependencies between snippets

• All manager classes must inherit from

  MonoBehaviour

  — required for Unity lifecycle methods (

  Start()

  ,

  OnDestroy()

  ) and to attach the script to a GameObject
• After generating any manager script, instruct the user to attach it to a persistent GameObject in their scene (the same one as the initializer, with

  DontDestroyOnLoad

  )
• For banner and interstitial managers, call

  DestroyAd()

  in

  OnDestroy()

  so ads are destroyed and memory is freed when the manager is destroyed
• Proper event subscription and unsubscription (to avoid memory leaks)
• Null checks and defensive programming
• Debug logs for troubleshooting
• Clear variable names that match LevelPlay conventions
• Error handling and graceful degradation

• If the user provided a bid floor value for a format, wrap construction in

  Config.Builder().SetBidFloor(value).Build()

  and pass the config to the constructor.
• If the user said 'skip' for that format, use the basic constructor (

  new LevelPlayRewardedAd(adUnitId)

  ).
• Apply per-format: a publisher may set a floor on rewarded but skip banner.

var config = new LevelPlayRewardedAd.Config.Builder()
    .SetBidFloor(0.80)
    .Build();
rewardedAd = new LevelPlayRewardedAd(adUnitId, config);

rewardedAd = new LevelPlayRewardedAd(adUnitId);

references/ilrd-api.md

references/ilrd-api.md

LevelPlay.OnImpressionDataReady

LevelPlay.Init()

// Initialize with your actual App Key (replace "abc123..." with yours)
// Mock ads work with any value, but use your real key to avoid forgetting to update it later
LevelPlay.Init("abc123youractualappkey");

// In OnInitSuccess callback:
// Use your real ad unit ID from LevelPlay dashboard (replace "12345..." with yours)
// Mock ads work with any value, but use your real IDs to avoid forgetting to update them later
LevelPlayRewardedAd rewardedAd = new LevelPlayRewardedAd("12345youractualadunitid");
rewardedAd.OnAdLoaded += OnAdLoaded;
rewardedAd.OnAdRewarded += OnAdRewarded;
rewardedAd.LoadAd();

• Mock ads work with any App Key/Ad Unit ID values (you can even use "test" or "editor")
• Recommended: Use your real credentials from Step 5 to avoid forgetting to update them later
• Mock ads appear automatically when testing in Unity Editor
• Real ads appear automatically when building to device
• Same code works everywhere - no switching or conditional compilation needed
• Android API 33+: If targeting Android 13+ devices, verify you've added the AD_ID permission to AndroidManifest.xml (see Step 4)

• Ad integration flow works correctly
• Most callbacks fire as expected (see callback behavior below)
• Ad loading, showing, and closing logic
• Ad positioning and layout (for banners)
• Basic ad logic and state management

• OnAdLoaded

  - Always fires after LoadAd()

• OnAdDisplayed

  - Fires when ShowAd() is called

• OnAdRewarded

  - Fires for rewarded ads (with test reward)

• OnAdClosed

  - Fires when mock ad is dismissed

• OnAdLoadFailed

  - Mock ads always succeed loading

• OnAdDisplayFailed

  - Mock ads always succeed showing

• OnAdClicked

  - Mock ads don't simulate user clicks

• OnAdExpanded

  /

  OnAdCollapsed

  - Banner expand/collapse not simulated

• OnAdLeftApplication

  - No real ad redirect in Editor

• OnAdInfoChanged

  - Mock ads don't update ad info dynamically

• LevelPlay.OnImpressionDataReady

  (ILRD) - No impression data generated in Editor

LevelPlay.OnInitSuccess

Start()

LevelPlay.Init()

OnInitSuccess

• Don't simulate network latency or failures
• Don't test real ad network behavior
• Don't validate reward logic server-side
• Placeholder UI instead of real ad creatives
• Error callbacks never fire

• All ad formats (Rewarded, Interstitial, Banner) with real ads
• SDK initialization with production App Key
• All callbacks fire correctly in production environment
• Real ad network behavior, latency, and edge cases
• Ad rendering and user interaction flows

• Unity Ads is pre-installed — the Ads Mediation package includes the Unity Ads adapter by default, so you have at least one network ready without any additional setup. For ads to fill on device, verify your LevelPlay dashboard has active instances configured for your ad units.
• Enable Development Build in Build Profiles (called Build Settings in Unity versions before Unity 6) before building to device. Without it, SDK console output won't be visible, making it very difficult to diagnose issues if something doesn't work as expected.

LevelPlayInitializer.cs

1. At the top of

   Start()

   , before

   LevelPlay.Init(appKey)

   :

LevelPlay.SetMetaData("is_test_suite", "enable");

1. Inside your

   OnInitSuccess

   callback:

LevelPlay.LaunchTestSuite();

LevelPlayInitializer.cs

using UnityEngine;
using Unity.Services.LevelPlay;

public class LevelPlayInitializer : MonoBehaviour
{
    [SerializeField] private string appKey;

    void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }

    void Start()
    {
        // Enable Test Suite — REMOVE before production release
        LevelPlay.SetMetaData("is_test_suite", "enable");

        LevelPlay.OnInitSuccess += OnInitSuccess;
        LevelPlay.OnInitFailed += OnInitFailed;
        LevelPlay.Init(appKey);
    }

    private void OnInitSuccess(LevelPlayConfiguration config)
    {
        Debug.Log("LevelPlay initialized successfully");
        // Launch Test Suite — REMOVE before production release
        LevelPlay.LaunchTestSuite();
    }

    private void OnInitFailed(LevelPlayInitError error)
    {
        Debug.LogError($"LevelPlay initialization failed: {error.ErrorMessage}");
    }

    void OnDestroy()
    {
        LevelPlay.OnInitSuccess -= OnInitSuccess;
        LevelPlay.OnInitFailed -= OnInitFailed;
    }
}

1. Attach it to a GameObject in your first scene
2. In the Unity Inspector, find the "App Key" field
3. Paste your App Key from Step 5 into that field

• LevelPlay.SetMetaData("is_test_suite", "enable");

  must be called BEFORE

  LevelPlay.Init()

  — if the Test Suite doesn't appear after launch, this is the most likely cause

• LevelPlay.LaunchTestSuite();

  is called AFTER successful initialization (in

  OnInitSuccess

  )
• Requires device build - Test Suite does not work in Unity Editor
• Use production App Key, not "editor"
• Build to Android or iOS device and run the app
• Test Suite UI will appear automatically after initialization

1. Add Test Suite code (SetMetaData before Init, LaunchTestSuite after OnInitSuccess)
2. Build to Android or iOS device
3. Run the app on device
4. Test Suite UI launches automatically
5. Follow on-screen instructions to test each ad format
6. Verify all ad formats load and callbacks fire correctly

• Test Suite validation completed successfully on device
• All ad formats load correctly (Rewarded, Interstitial, Banner if implemented)
• All callbacks fire as expected
• App Key and ad unit IDs verified correct for production
• Tested on multiple devices (different screen sizes, OS versions)
• iOS-specific requirements completed (if targeting iOS):
  • SKAdNetwork IDs configured in Info.plist (see

    references/ios-setup.md

    )
  • App Tracking Transparency (ATT) framework implemented (see

    references/ios-setup.md

    )
  • iOS privacy manifest configured if required
  • Tested on physical iOS device (not just simulator)
• Android-specific requirements completed (if targeting Android):
  • Google Play Services dependencies resolved (Step 4 completed)
  • AD_ID permission added to AndroidManifest.xml if targeting API 33+ (see Step 4)
  • Tested on physical Android device
• Tested with real ads in production environment
• Ad frequency capping implemented (if using interstitials)
• Error handling works correctly (test with airplane mode - ads should fail gracefully without crashing or blocking gameplay)

1. Skip to Step 9 - You don't need to repeat the initial setup steps. Before proceeding, verify your existing initialization still works by checking the Unity console for the 'LevelPlay SDK initialized successfully' log.
2. Choose the additional formats you want to implement
3. Follow the same organization pattern you used before:
   • If you created separate manager scripts, create a new manager script for the new format
   • If you used a unified AdManager, add the new format's code to your existing AdManager class
   • If you used code snippets, integrate new snippets following the same pattern
4. Follow the same implementation guidelines from Step 9 for the new ad format
5. Test the new format following Step 10 testing guidelines

• Create

  InterstitialAdManager.cs

  following the same structure as your

  RewardedAdManager.cs

• Follow the interstitial implementation guidelines from

  references/interstitial-api.md

• Test the interstitial ads in Unity Editor and on device

• Load immediately after SDK initialization (load proactively means load early and keep ads preloaded)
• Reload immediately after showing or when ad fails to load
• Always keep a rewarded ad ready to show

• Load proactively before natural break points
• Maintain a loaded interstitial for opportunistic moments
• Reload after showing

• Load when entering scenes where banners will be displayed
• Destroy banners when leaving those scenes to free memory

• High engagement (post-victory, level up): Best for rewarded ads
• Natural transitions (level complete, menu navigation): Good for interstitials
• Low attention (waiting periods, menus): Acceptable for banners

• Compiler errors:

  The type or namespace name 'LevelPlay' could not be found

• Compiler errors:

  The type or namespace name 'Unity.Services.LevelPlay' could not be found

• Red underlines in Unity Editor on all LevelPlay code

1. Stop providing code immediately
2. Ask: "Can you confirm the Ads Mediation package is installed? Check Window > Package Manager and verify 'Ads Mediation' appears under 'Packages: In Project'"
3. If not installed, direct to Step 3 to install via Unity Package Manager
4. Have them restart Unity Editor after installation (important!)
5. Verify installation by checking that

   using Unity.Services.LevelPlay;

   no longer shows errors
6. Only resume code generation after confirmation and verification

• Android: Gradle build errors mentioning missing dependencies or classes
• iOS: CocoaPods errors, missing frameworks, or linker errors
• Code compiles perfectly in Unity Editor but fails during platform build
• Build succeeds in Editor but crashes immediately on device

1. Verify you have a dependency manager installed (Mobile Dependency Resolver, Unity External Dependency Manager, or EDM4U)
2. Check your project's Assets folder for dependency manager tools
3. Run dependency resolution:
   • Android (newer MDR versions): Should auto-resolve on build. If failing, manually resolve via Assets > Mobile Dependency Resolver > Android Resolver > Resolve
   • Android (older/other managers): Assets > [Your Dependency Manager] > Android Resolver > Resolve
   • iOS (all managers): Assets > [Your Dependency Manager] > iOS Resolver > Install Cocoapods
4. Verify resolution:
   • Android: Check

     Assets/Plugins/Android/

     for gradle files
   • iOS: Look for Podfile or CocoaPods confirmation in console
5. If you don't have a dependency manager, restart Unity - you should see a prompt to install Mobile Dependency Resolver
6. Rebuild for your target platform after resolution

• SDK not initialized before loading ads
• Incorrect App Key
• Ad object created before initialization completes
• Network connectivity issues
• Ad inventory not available in test region

• Verify

  LevelPlay.Init()

  is called and

  OnInitSuccess

  fires before creating ad objects
• Create ad objects only after

  OnInitSuccess

  callback
• Check App Key matches LevelPlay dashboard
• Test on real devices with active internet connection
• Enable test mode in LevelPlay dashboard for guaranteed test ads (Note: dashboard test mode is separate from mock ads in the Unity Editor — it enables real test ads on device)

• Events registered after SDK initialization
• Missing event subscriptions
• Script destroyed before callbacks execute

• Register callbacks before calling

  Init()

• Verify all callbacks are subscribed (check with Debug.Log statements)
• Use persistent GameObject with DontDestroyOnLoad if needed

• Ensure SKAdNetwork IDs are configured in Info.plist
• Verify ATT is implemented correctly (see

  references/ios-setup.md

  )
• Check Xcode build settings for required frameworks

• Verify Google Play Services is included
• Check AndroidManifest.xml for required permissions
• Ensure Gradle dependencies are resolved

• references/rewarded-api.md

  : When implementing rewarded ads

• references/interstitial-api.md

  : When implementing interstitial ads

• references/banner-api.md

  : When implementing banner ads

• references/initialization-api.md

  : When user ID tracking, segmentation, consent management, or advanced SDK configuration options are needed

• references/ios-setup.md

  : When targeting iOS builds

• references/best-practices.md

  : When user asks for optimization guidance or troubleshooting

• references/privacy-settings.md

  : When GDPR, CCPA, or COPPA compliance is needed

• references/ilrd-api.md

  : When wiring ILRD to an analytics platform

1. Verify Unity project (Step 1)
2. Ask about optimization goal (Step 2)
3. Verify SDK installed (Step 3)
4. Verify dependencies resolved (Step 4)
5. Verify they have App Key (Step 5)
6. Verify AdMob config if needed (Step 6)
7. Verify SDK initialized (Step 7)
8. Recommend revenue-focused strategy (Step 8)
9. Ask about code organization preference (Step 9)
10. Generate appropriate code structure (Step 9)
11. Guide through testing (Step 10)

1. Verify Unity project (Step 1)
2. Ask about optimization goal (Step 2)
3. Verify SDK installed (Step 3)
4. Verify dependencies resolved (Step 4)
5. Verify they have App Key (Step 5)
6. Verify AdMob config if needed (Step 6)
7. Verify SDK initialized (Step 7)
8. Recommend UX-focused strategy (Step 8): Rewarded only, user-initiated
9. Ask about code organization preference (Step 9)
10. Provide implementation with proper patterns (Step 9)
11. Guide through testing (Step 10)

1. Verify Unity project (Step 1)
2. Ask about optimization goal (Step 2)
3. Verify SDK installed (Step 3)
4. Verify dependencies resolved (Step 4)
5. Verify they have App Key (Step 5)
6. Verify AdMob config if needed (Step 6)
7. Verify SDK initialized (Step 7)
8. Recommend balanced strategy (Step 8)
9. Ask to see existing GameManager.cs, then provide code snippets (Step 9)
10. Guide through testing (Step 10)