diff --git a/tools/testing/kunit/kunit.py b/tools/testing/kunit/kunit.py
index 938b0da..34c0eb5d 100755
--- a/tools/testing/kunit/kunit.py
+++ b/tools/testing/kunit/kunit.py
@@ -10,6 +10,7 @@
 
 import kunit_config
 import kunit_kernel
+import kunit_new_template
 import kunit_parser
 
 def run_tests(cli_args, linux):
@@ -50,6 +51,11 @@
 				build_end - build_start,
 				test_end - test_start)))
 
+def print_test_skeletons(cli_args):
+	kunit_new_template.create_skeletons_from_path(
+			cli_args.path,
+			namespace_prefix=cli_args.namespace_prefix)
+
 def main(argv, linux=kunit_kernel.LinuxSourceTree()):
 	parser = argparse.ArgumentParser(
 			description='Helps writing and running KUnit tests.')
@@ -67,9 +73,22 @@
 				default=300,
 				metavar='timeout')
 
+	new_parser = subparser.add_parser(
+			'new',
+			help='Prints out boilerplate for writing new tests.')
+	new_parser.add_argument('--path',
+				help='Path of source file to be tested.',
+				type=str,
+				required=True)
+	new_parser.add_argument('--namespace_prefix',
+				help='Namespace of the code to be tested.',
+				type=str)
+
 	cli_args = parser.parse_args(argv)
 
-	if cli_args.subcommand == 'run':
+	if cli_args.subcommand == 'new':
+		print_test_skeletons(cli_args)
+	elif cli_args.subcommand == 'run':
 		run_tests(cli_args, linux)
 	else:
 		parser.print_help()
diff --git a/tools/testing/kunit/kunit_new_template.py b/tools/testing/kunit/kunit_new_template.py
new file mode 100644
index 0000000..1b4516d
--- /dev/null
+++ b/tools/testing/kunit/kunit_new_template.py
@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: GPL-2.0
+
+import os
+import string
+
+TEMPLATE_DIR = os.path.dirname(os.path.abspath(__file__))
+TEST_TEMPLATE_PATH = os.path.join(TEMPLATE_DIR, 'test_template.c')
+KCONFIG_TEMPLATE_PATH = os.path.join(TEMPLATE_DIR, 'test_template.Kconfig')
+MAKEFILE_TEMPLATE_PATH = os.path.join(TEMPLATE_DIR, 'test_template.Makefile')
+
+def create_skeleton_from_template(template_path, test_prefix, test_object_file):
+	with open(template_path, 'r') as f:
+		return string.Template(f.read()).safe_substitute(
+				test_prefix=test_prefix,
+				caps_test_prefix=test_prefix.upper(),
+				test_object_file=test_object_file)
+
+
+class Skeletons(object):
+	"""
+	Represents the KUnit skeletons for a test, Kconfig entry, and Makefile
+	entry.
+	"""
+	def __init__(self, test_skeleton, kconfig_skeleton, makefile_skeleton):
+		self.test_skeleton = test_skeleton
+		self.kconfig_skeleton = kconfig_skeleton
+		self.makefile_skeleton = makefile_skeleton
+
+
+def create_skeletons(namespace_prefix, test_object_file):
+	test_prefix = namespace_prefix + '_test'
+	return Skeletons(
+			test_skeleton=create_skeleton_from_template(
+					TEST_TEMPLATE_PATH,
+					test_prefix,
+					test_object_file),
+			kconfig_skeleton=create_skeleton_from_template(
+					KCONFIG_TEMPLATE_PATH,
+					test_prefix,
+					test_object_file),
+			makefile_skeleton=create_skeleton_from_template(
+					MAKEFILE_TEMPLATE_PATH,
+					test_prefix,
+					test_object_file)
+	)
+
+def namespace_prefix_from_path(path):
+	file_name = os.path.basename(path)
+	return os.path.splitext(file_name)
+
+def create_skeletons_from_path(path, namespace_prefix=None):
+	dir_name, file_name = os.path.split(path)
+	file_prefix, _ = os.path.splitext(file_name)
+	test_path = os.path.join(dir_name, file_prefix + '-test.c')
+	test_object_file = file_prefix + '-test.o'
+	if not namespace_prefix:
+		namespace_prefix = file_prefix.replace('-', '_')
+	skeletons = create_skeletons(namespace_prefix, test_object_file)
+	print('### In ' + test_path)
+	print(skeletons.test_skeleton)
+	print('### In Kconfig')
+	print(skeletons.kconfig_skeleton)
+	print('### In Makefile')
+	print(skeletons.makefile_skeleton)
+
diff --git a/tools/testing/kunit/kunit_test.py b/tools/testing/kunit/kunit_test.py
index 816ba07..e7baf2868 100755
--- a/tools/testing/kunit/kunit_test.py
+++ b/tools/testing/kunit/kunit_test.py
@@ -207,5 +207,25 @@
 		self.linux_source_mock.run_kernel.assert_called_once_with(timeout=timeout)
 		self.print_mock.assert_any_call(StrContains('Testing complete.'))
 
+	def test_new_no_namespace(self):
+		kunit.main(['new', '--path', 'drivers/i2c/busses/i2c-aspeed.c'], self.linux_source_mock)
+		assert self.linux_source_mock.build_reconfig.call_count == 0
+		assert self.linux_source_mock.run_kernel.call_count == 0
+		self.print_mock.assert_any_call(StrContains('i2c_aspeed'))
+		for kall in self.print_mock.call_args_list:
+			assert kall != mock.call(StrContains('aspeed_i2c'))
+
+	def test_new_with_namespace(self):
+		namespace_prefix = 'aspeed_i2c'
+		kunit.main([
+				'new',
+				'--path', 'drivers/i2c/busses/i2c-aspeed.c',
+				'--namespace_prefix', namespace_prefix],
+			   self.linux_source_mock)
+		assert self.linux_source_mock.build_reconfig.call_count == 0
+		assert self.linux_source_mock.run_kernel.call_count == 0
+		self.print_mock.assert_any_call(StrContains('i2c-aspeed'))
+		self.print_mock.assert_any_call(StrContains('aspeed_i2c'))
+
 if __name__ == '__main__':
 	unittest.main()
diff --git a/tools/testing/kunit/test_template.Kconfig b/tools/testing/kunit/test_template.Kconfig
new file mode 100644
index 0000000..1bdafb3
--- /dev/null
+++ b/tools/testing/kunit/test_template.Kconfig
@@ -0,0 +1,5 @@
+config ${caps_test_prefix}
+	bool "KUnit test for ${test_prefix}"
+	depends on TEST
+	help
+	  TODO: Describe config fully.
diff --git a/tools/testing/kunit/test_template.Makefile b/tools/testing/kunit/test_template.Makefile
new file mode 100644
index 0000000..b32a538
--- /dev/null
+++ b/tools/testing/kunit/test_template.Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_${caps_test_prefix})	+= ${test_object_file}
diff --git a/tools/testing/kunit/test_template.c b/tools/testing/kunit/test_template.c
new file mode 100644
index 0000000..b2169cc
--- /dev/null
+++ b/tools/testing/kunit/test_template.c
@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * TODO: Add test description.
+ */
+
+#include <test/test.h>
+#include <test/mock.h>
+
+/*
+ * This is the most fundamental element of KUnit, the test case. A test case
+ * makes a set EXPECTATIONs and ASSERTIONs about the behavior of some code; if
+ * any expectations or assertions are not met, the test fails; otherwise, the
+ * test passes.
+ *
+ * In KUnit, a test case is just a function with the signature
+ * `void (*)(struct test *)`. `struct test` is a context object that stores
+ * information about the current test.
+ */
+static void ${test_prefix}_foo(struct test *test)
+{
+	/*
+	 * This is an EXPECTATION; it is how KUnit tests things. When you want
+	 * to test a piece of code, you set some expectations about what the
+	 * code should do. KUnit then runs the test and verifies that the code's
+	 * behavior matched what was expected.
+	 */
+	EXPECT_EQ(test, 1, 2); // Obvious failure.
+}
+
+/*
+ * This is run once before each test case, see the comment on
+ * example_test_module for more information.
+ */
+static int ${test_prefix}_init(struct test *test)
+{
+	return 0;
+}
+
+/*
+ * This is run once after each test case, see the comment on example_test_module
+ * for more information.
+ */
+static void ${test_prefix}_exit(struct test *test)
+{
+}
+
+/*
+ * Here we make a list of all the test cases we want to add to the test module
+ * below.
+ */
+static struct test_case ${test_prefix}_cases[] = {
+	/*
+	 * This is a helper to create a test case object from a test case
+	 * function; its exact function is not important to understand how to
+	 * use KUnit, just know that this is how you associate test cases with a
+	 * test module.
+	 */
+	TEST_CASE(${test_prefix}_foo),
+	{},
+};
+
+/*
+ * This defines a suite or grouping of tests.
+ *
+ * Test cases are defined as belonging to the suite by adding them to
+ * `test_cases`.
+ *
+ * Often it is desirable to run some function which will set up things which
+ * will be used by every test; this is accomplished with an `init` function
+ * which runs before each test case is invoked. Similarly, an `exit` function
+ * may be specified which runs after every test case and can be used to for
+ * cleanup. For clarity, running tests in a test module would behave as follows:
+ *
+ * module.init(test);
+ * module.test_case[0](test);
+ * module.exit(test);
+ * module.init(test);
+ * module.test_case[1](test);
+ * module.exit(test);
+ * ...;
+ */
+static struct test_module ${test_prefix}_module = {
+	.name = "${test_prefix}",
+	.init = ${test_prefix}_init,
+	.exit = ${test_prefix}_exit,
+	.test_cases = ${test_prefix}_cases,
+};
+
+/*
+ * This registers the above test module telling KUnit that this is a suite of
+ * tests that need to be run.
+ */
+module_test(${test_prefix}_module);