From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

```class SeatGeekPlugin : Plugin&lt;Project&gt; {

    override fun apply(target: Project) = with(target) {
        val arch2 = extensions.create("arch2", Arch2PluginExtension::class.java)

        afterEvaluate {
            if (arch2.isConfigured) {
                val moduleSetup = archetypeConfigToModuleSetup(target, arch2.archetypeConfig)

                moduleSetup.plugins.forEach { plugin -&gt;
                    println("Plugin: $plugin")

                    when (plugin) {
                        is Plugin.Class -&gt; project.plugins.apply(plugin.clazz)
                        is Plugin.Id -&gt; project.plugins.apply(plugin.id)
                    }
                }

                moduleSetup.dependencies.forEach { dep -&gt;
                    when (dep) {
                        is Dependency.Maven -&gt; target.dependencies.add(dep.configuration.asGradleConfigurationString(), dep.coordinates)
                        is Dependency.Module -&gt; target.dependencies.module("${dep.configuration.asGradleConfigurationString()} ${dep.path}")
                    }
                }
            }
        }
    }
...
}```


The plugin *is* applied in time.
Indeed immediately.
Even though you use the legacy way of applying it instead of the `plugins` block.
But you explicitly delay most of the work to later, after the build script was evalutated using `afterEvaluate` which is almost never a good idea to use.

hmm, it seemed that if I didn't include it in afterEvaluate {} then the arch2 extension wasn't yet parsed from the build.gradle

So with this feedback I tried something different -- injecting project into the extension and then applying the necessary plugins from the view{} block and that seems to work. Is that the "right" way?

Of course the extension is not yet configured without `afterEvalutate`, as the `apply` is of course before the extension.
When the plugin is applied it adds the extension, so it cannot be configured before the plugin is applied.
I'm not sure how you mean it exactly, but I guess yes, having a method in `view` instead of a property and reacting to the method call.

It's working! Configuring the project from within the Extension implementation :party-gradlephant: