description = "Provides a set of plugins that are shared between the Gradle and build-logic builds"

tasks.register("check") {
    dependsOn(subprojects.map { "${it.name}:check" })

        // Serialize an inner child here so that the BaseObject.childrenTracking is non null
        Build build = model.getBuild();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(build);
        }

        Build build2;
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

The build is then included in the root project's _settings_ file as seen in the above snippet.
For more details about included builds, see link:{userManualPath}/composite_builds.html[Composing Builds] chapter.

The `myproject.java-conventions` plugin is then applied to the `buildSrc` build:
====
include::sample[dir="kotlin",files="buildSrc/build.gradle.kts[tags=plugins]"]

# See the License for the specific language governing permissions and
# limitations under the License.

# This script builds a multi-arch kind node image
# Largely copied from https://github.com/kubernetes-sigs/kind/blob/2a1e9df91fd22d6ae5b91648b6c1a606ab4cdf30/hack/release/build/push-node.sh
# Example usage: `tools/build-kind-image.sh ~/go/src/k8s.io/kubernetes gcr.io/istio-testing/kind-node:v1.23.4`

set -uex

kdir="${1:?Kubernetes directory}"

    doLast {
        fileCollection.files
    }
}
"""
        // Ensure build scripts compiled
        run("help")

        when:
        def build1 = executer.withTasks("redThings").withArgument("-Dcrash=true").start()
        build1.waitForFailure()

        run("redThings")

        then:
        output.count("Transforming") == 1

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 * </p>
 * <strong>Note:</strong> This interface is part of work in progress and can be changed or removed without notice.
 */
public interface Builder {
    //

# This script runs `curl` command to get the kubernetes build file.
# Version number or publication is either a proper version number'
# (e.g. "v1.0.6", "v1.2.0-alpha.1.881+376438b69c7612") or a version'
#  publication of the form <bucket>/<version> (e.g. "release/stable",'
# "ci/latest-1").'

# Usage `hack/get-build.sh [Version]`.
# Example `hack/get-build.sh v1.16.4`.

set -o errexit
set -o nounset
set -o pipefail

== Step 1. Understanding Incremental Builds
It's important to know that Gradle optimizes your build in a variety of ways.
One such optimization is called _incremental builds_.

An _incremental build_ is a build that avoids running tasks whose inputs did not change since the previous build, making the execution of such tasks unnecessary.

// If the command fails, Run reports the error using Errorf.
func Run(cmdargs ...any) {
	cmdline := str.StringList(cmdargs...)
	if cfg.BuildN || cfg.BuildX {
		fmt.Printf("%s\n", strings.Join(cmdline, " "))
		if cfg.BuildN {
			return
		}
	}

	cmd := exec.Command(cmdline[0], cmdline[1:]...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {

	*f.value = v
	if v != "" {
		*f.explicit = true
	}
	return nil
}

// AddBuildFlagsNX adds the -n and -x build flags to the flag set.
func AddBuildFlagsNX(flags *flag.FlagSet) {
	flags.BoolVar(&cfg.BuildN, "n", false, "")
	flags.BoolVar(&cfg.BuildX, "x", false, "")
}

// AddChdirFlag adds the -C flag to the flag set.
func AddChdirFlag(flags *flag.FlagSet) {