diff --git a/pkg/assets/assets.go b/pkg/assets/assets.go
index 73049c0..bdb4e8b 100644
--- a/pkg/assets/assets.go
+++ b/pkg/assets/assets.go
@@ -44,11 +44,7 @@ func GetKubeSawAdminsConfig(kubeSawAdminsFile string) (*KubeSawAdmins, error) {
 }
 
 func GetRoles(f fs.ReadFileFS, clusterType configuration.ClusterType) ([]runtimeclient.Object, error) {
-	return GetSetupTemplateObjects(f, fmt.Sprintf("roles/%s.yaml", clusterType))
-}
-
-func GetSetupTemplateObjects(f fs.ReadFileFS, filePath string) ([]runtimeclient.Object, error) {
-	return ParseTemplate(f, fmt.Sprintf("setup/%s", filePath))
+	return ParseTemplate(f, fmt.Sprintf("roles/%s.yaml", clusterType))
 }
 
 func ParseTemplate(f fs.ReadFileFS, fileName string) ([]runtimeclient.Object, error) {
diff --git a/pkg/assets/assets_test.go b/pkg/assets/assets_test.go
index 90a0bce..5a2fbf7 100644
--- a/pkg/assets/assets_test.go
+++ b/pkg/assets/assets_test.go
@@ -61,8 +61,8 @@ func TestGetRoles(t *testing.T) {
 	// given
 	require.NoError(t, client.AddToScheme())
 	files := NewFakeFiles(t,
-		FakeFile("setup/roles/host.yaml", []byte(hostRoles)),
-		FakeFile("setup/roles/member.yaml", []byte(memberRoles)),
+		FakeFile("roles/host.yaml", []byte(hostRoles)),
+		FakeFile("roles/member.yaml", []byte(memberRoles)),
 	)
 
 	for _, clusterType := range configuration.ClusterTypes {
diff --git a/pkg/cmd/generate/admin-manifests.go b/pkg/cmd/generate/admin-manifests.go
index 0e35d91..0e19ff9 100644
--- a/pkg/cmd/generate/admin-manifests.go
+++ b/pkg/cmd/generate/admin-manifests.go
@@ -14,13 +14,13 @@ import (
 	"github.com/spf13/cobra"
 )
 
-type setupFlags struct {
+type adminManifestsFlags struct {
 	kubeSawAdminsFile, outDir, hostRootDir, memberRootDir string
 	singleCluster                                         bool
 }
 
 func NewAdminManifestsCmd() *cobra.Command {
-	f := setupFlags{}
+	f := adminManifestsFlags{}
 	command := &cobra.Command{
 		Use: "admin-manifests --kubesaw-admins=<path-to-kubesaw-admins-file> --out-dir <path-to-out-dir>",
 		Example: `ksctl generate admin-manifests ./path/to/kubesaw.openshiftapps.com/kubesaw-admins.yaml --out-dir ./components/auth/kubesaw-production
@@ -30,7 +30,7 @@ ksctl generate admin-manifests ./path/to/kubesaw-stage.openshiftapps.com/kubesaw
 		Args:  cobra.ExactArgs(0),
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			term := ioutils.NewTerminal(cmd.InOrStdin, cmd.OutOrStdout)
-			return Setup(term, resources.Resources, f)
+			return adminManifests(term, resources.Resources, f)
 		},
 	}
 	command.Flags().StringVarP(&f.kubeSawAdminsFile, "kubesaw-admins", "c", "", "Use the given kubesaw-admin file")
@@ -45,7 +45,7 @@ ksctl generate admin-manifests ./path/to/kubesaw-stage.openshiftapps.com/kubesaw
 	return command
 }
 
-func Setup(term ioutils.Terminal, files assets.FS, flags setupFlags) error {
+func adminManifests(term ioutils.Terminal, files assets.FS, flags adminManifestsFlags) error {
 	if err := client.AddToScheme(); err != nil {
 		return err
 	}
@@ -64,11 +64,11 @@ func Setup(term ioutils.Terminal, files assets.FS, flags setupFlags) error {
 	if err != nil {
 		return err
 	}
-	ctx := &setupContext{
-		Terminal:      term,
-		kubeSawAdmins: kubeSawAdmins,
-		setupFlags:    flags,
-		files:         files,
+	ctx := &adminManifestsContext{
+		Terminal:            term,
+		kubeSawAdmins:       kubeSawAdmins,
+		adminManifestsFlags: flags,
+		files:               files,
 	}
 	objsCache := objectsCache{}
 	if err := ensureCluster(ctx, configuration.Host, objsCache); err != nil {
@@ -80,19 +80,19 @@ func Setup(term ioutils.Terminal, files assets.FS, flags setupFlags) error {
 	return objsCache.writeManifests(ctx)
 }
 
-type setupContext struct {
+type adminManifestsContext struct {
 	ioutils.Terminal
-	setupFlags
+	adminManifestsFlags
 	kubeSawAdmins *assets.KubeSawAdmins
 	files         assets.FS
 }
 
-func ensureCluster(ctx *setupContext, clusterType configuration.ClusterType, cache objectsCache) error {
+func ensureCluster(ctx *adminManifestsContext, clusterType configuration.ClusterType, cache objectsCache) error {
 	ctx.PrintContextSeparatorf("Generating manifests for %s cluster type", clusterType)
 
 	clusterCtx := &clusterContext{
-		setupContext: ctx,
-		clusterType:  clusterType,
+		adminManifestsContext: ctx,
+		clusterType:           clusterType,
 	}
 
 	if err := ensureServiceAccounts(clusterCtx, cache); err != nil {
diff --git a/pkg/cmd/generate/admin-manifests_test.go b/pkg/cmd/generate/admin-manifests_test.go
index 4c2bdc9..1f893a7 100644
--- a/pkg/cmd/generate/admin-manifests_test.go
+++ b/pkg/cmd/generate/admin-manifests_test.go
@@ -20,7 +20,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-func TestSetup(t *testing.T) {
+func TestAdminManifests(t *testing.T) {
 	// given
 	require.NoError(t, client.AddToScheme())
 	kubeSawAdmins := NewKubeSawAdmins(
@@ -50,14 +50,14 @@ func TestSetup(t *testing.T) {
 
 	t.Run("all created", func(t *testing.T) {
 		// given
-		outTempDir, err := os.MkdirTemp("", "setup-cli-test-")
+		outTempDir, err := os.MkdirTemp("", "admin-manifests-cli-test-")
 		require.NoError(t, err)
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile(configFile))
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile(configFile))
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.NoError(t, err)
@@ -66,14 +66,14 @@ func TestSetup(t *testing.T) {
 
 	t.Run("in single-cluster mode", func(t *testing.T) {
 		// given
-		outTempDir, err := os.MkdirTemp("", "setup-cli-test-")
+		outTempDir, err := os.MkdirTemp("", "admin-manifests-cli-test-")
 		require.NoError(t, err)
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile(configFile), singleCluster())
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile(configFile), singleCluster())
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.NoError(t, err)
@@ -82,14 +82,14 @@ func TestSetup(t *testing.T) {
 
 	t.Run("in custom host root directory", func(t *testing.T) {
 		// given
-		outTempDir, err := os.MkdirTemp("", "setup-cli-test-")
+		outTempDir, err := os.MkdirTemp("", "admin-manifests-cli-test-")
 		require.NoError(t, err)
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile(configFile), hostRootDir("host-cluster"))
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile(configFile), hostRootDir("host-cluster"))
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.NoError(t, err)
@@ -98,14 +98,14 @@ func TestSetup(t *testing.T) {
 
 	t.Run("in custom member root directory", func(t *testing.T) {
 		// given
-		outTempDir, err := os.MkdirTemp("", "setup-cli-test-")
+		outTempDir, err := os.MkdirTemp("", "admin-manifests-cli-test-")
 		require.NoError(t, err)
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile(configFile), memberRootDir("member-clusters"))
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile(configFile), memberRootDir("member-clusters"))
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.NoError(t, err)
@@ -114,15 +114,15 @@ func TestSetup(t *testing.T) {
 
 	t.Run("previous deleted", func(t *testing.T) {
 		// given
-		outTempDir, err := os.MkdirTemp("", "setup-cli-test-")
+		outTempDir, err := os.MkdirTemp("", "admin-manifests-cli-test-")
 		require.NoError(t, err)
 		storeDummySA(t, outTempDir)
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile(configFile))
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile(configFile))
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.NoError(t, err)
@@ -131,13 +131,13 @@ func TestSetup(t *testing.T) {
 
 	t.Run("if out dir doesn't exist then it creates", func(t *testing.T) {
 		// given
-		outTempDir := filepath.Join(os.TempDir(), fmt.Sprintf("setup-cli-test-%s", uuid.NewV4().String()))
+		outTempDir := filepath.Join(os.TempDir(), fmt.Sprintf("admin-manifests-cli-test-%s", uuid.NewV4().String()))
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile(configFile))
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile(configFile))
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.NoError(t, err)
@@ -146,14 +146,14 @@ func TestSetup(t *testing.T) {
 
 	t.Run("fails for non-existing kubesaw-admins.yaml file", func(t *testing.T) {
 		// given
-		outTempDir, err := os.MkdirTemp("", "setup-cli-test-")
+		outTempDir, err := os.MkdirTemp("", "admin-manifests-cli-test-")
 		require.NoError(t, err)
 		term := NewFakeTerminalWithResponse("Y")
 		term.Tee(os.Stdout)
-		flags := newSetupFlags(outDir(outTempDir), kubeSawAdminsFile("does/not/exist"))
+		flags := newAdminManifestsFlags(outDir(outTempDir), kubeSawAdminsFile("does/not/exist"))
 
 		// when
-		err = Setup(term, files, flags)
+		err = adminManifests(term, files, flags)
 
 		// then
 		require.Error(t, err)
@@ -161,7 +161,7 @@ func TestSetup(t *testing.T) {
 }
 
 func storeDummySA(t *testing.T, outDir string) {
-	ctx := newSetupContextWithDefaultFiles(t, nil)
+	ctx := newAdminManifestsContextWithDefaultFiles(t, nil)
 	ctx.outDir = outDir
 	sa := &corev1.ServiceAccount{
 		TypeMeta: metav1.TypeMeta{
@@ -177,7 +177,7 @@ func storeDummySA(t *testing.T, outDir string) {
 	require.NoError(t, err)
 }
 
-func verifyFiles(t *testing.T, flags setupFlags) {
+func verifyFiles(t *testing.T, flags adminManifestsFlags) {
 	dirEntries, err := os.ReadDir(flags.outDir)
 	require.NoError(t, err)
 	var dirNames []string
@@ -307,45 +307,45 @@ users:
     token: my-cool-token
 `
 
-type setupFlagsOption func(*setupFlags)
+type adminManifestsFlagsOption func(*adminManifestsFlags)
 
-func newSetupFlags(setupFlagsOptions ...setupFlagsOption) setupFlags {
-	flags := setupFlags{
+func newAdminManifestsFlags(adminManifestsFlagsOptions ...adminManifestsFlagsOption) adminManifestsFlags {
+	flags := adminManifestsFlags{
 		hostRootDir:   "host",
 		memberRootDir: "member",
 	}
-	for _, applyOption := range setupFlagsOptions {
+	for _, applyOption := range adminManifestsFlagsOptions {
 		applyOption(&flags)
 	}
 	return flags
 }
 
-func kubeSawAdminsFile(configName string) setupFlagsOption {
-	return func(flags *setupFlags) {
+func kubeSawAdminsFile(configName string) adminManifestsFlagsOption {
+	return func(flags *adminManifestsFlags) {
 		flags.kubeSawAdminsFile = configName
 	}
 }
 
-func outDir(outDir string) setupFlagsOption {
-	return func(flags *setupFlags) {
+func outDir(outDir string) adminManifestsFlagsOption {
+	return func(flags *adminManifestsFlags) {
 		flags.outDir = outDir
 	}
 }
 
-func hostRootDir(hostRootDir string) setupFlagsOption {
-	return func(flags *setupFlags) {
+func hostRootDir(hostRootDir string) adminManifestsFlagsOption {
+	return func(flags *adminManifestsFlags) {
 		flags.hostRootDir = hostRootDir
 	}
 }
 
-func memberRootDir(memberRootDir string) setupFlagsOption {
-	return func(flags *setupFlags) {
+func memberRootDir(memberRootDir string) adminManifestsFlagsOption {
+	return func(flags *adminManifestsFlags) {
 		flags.memberRootDir = memberRootDir
 	}
 }
 
-func singleCluster() setupFlagsOption {
-	return func(flags *setupFlags) {
+func singleCluster() adminManifestsFlagsOption {
+	return func(flags *adminManifestsFlags) {
 		flags.singleCluster = true
 	}
 }
diff --git a/pkg/cmd/generate/cluster.go b/pkg/cmd/generate/cluster.go
index c124433..b2c1169 100644
--- a/pkg/cmd/generate/cluster.go
+++ b/pkg/cmd/generate/cluster.go
@@ -5,7 +5,7 @@ import (
 )
 
 type clusterContext struct {
-	*setupContext
+	*adminManifestsContext
 	clusterType configuration.ClusterType
 }
 
diff --git a/pkg/cmd/generate/cluster_test.go b/pkg/cmd/generate/cluster_test.go
index 44d8fce..3b35c7b 100644
--- a/pkg/cmd/generate/cluster_test.go
+++ b/pkg/cmd/generate/cluster_test.go
@@ -23,7 +23,7 @@ func TestEnsureServiceAccounts(t *testing.T) {
 					HostRoleBindings("toolchain-host-operator", Role("restart-deployment"), ClusterRole("view")),
 					MemberRoleBindings("toolchain-member-operator", Role("restart-deployment"), ClusterRole("view")))),
 			[]assets.User{})
-		ctx := newSetupContextWithDefaultFiles(t, kubeSawAdmins)
+		ctx := newAdminManifestsContextWithDefaultFiles(t, kubeSawAdmins)
 		cache := objectsCache{}
 
 		for _, clusterType := range configuration.ClusterTypes {
@@ -73,7 +73,7 @@ func TestEnsureServiceAccounts(t *testing.T) {
 				Sa("john", "openshift-customer-monitoring",
 					HostRoleBindings("toolchain-host-operator", Role("install-operator"), ClusterRole("view")),
 					HostClusterRoleBindings("cluster-monitoring-view"))), Users())
-		ctx := newSetupContextWithDefaultFiles(t, kubeSawAdmins)
+		ctx := newAdminManifestsContextWithDefaultFiles(t, kubeSawAdmins)
 		clusterCtx := newFakeClusterContext(ctx, configuration.Host)
 		t.Cleanup(gock.OffAll)
 		cache := objectsCache{}
@@ -106,7 +106,7 @@ func TestUsers(t *testing.T) {
 					MemberRoleBindings("toolchain-member-operator", Role("restart-deployment"), ClusterRole("view")),
 					MemberClusterRoleBindings("cluster-monitoring-view"))))
 
-		ctx := newSetupContextWithDefaultFiles(t, kubeSawAdmins)
+		ctx := newAdminManifestsContextWithDefaultFiles(t, kubeSawAdmins)
 		cache := objectsCache{}
 
 		for _, clusterType := range configuration.ClusterTypes {
diff --git a/pkg/cmd/generate/generate.go b/pkg/cmd/generate/generate.go
index ffc1f92..ce187f2 100644
--- a/pkg/cmd/generate/generate.go
+++ b/pkg/cmd/generate/generate.go
@@ -5,16 +5,16 @@ import (
 )
 
 func NewGenerateCmd() *cobra.Command {
-	admCommand := &cobra.Command{
+	generateCommand := &cobra.Command{
 		Use:   "generate",
 		Short: "Generate commands",
 		Long:  `Commands to generate manifests and CLI config files`,
 	}
-	registerCommands(admCommand)
-	return admCommand
+	registerCommands(generateCommand)
+	return generateCommand
 }
 
-func registerCommands(admCommand *cobra.Command) {
-	admCommand.AddCommand(NewAdminManifestsCmd())
-	admCommand.AddCommand(NewCliConfigsCmd())
+func registerCommands(generateCommand *cobra.Command) {
+	generateCommand.AddCommand(NewAdminManifestsCmd())
+	generateCommand.AddCommand(NewCliConfigsCmd())
 }
diff --git a/pkg/cmd/generate/mock_test.go b/pkg/cmd/generate/mock_test.go
index 0ecbba6..130c841 100644
--- a/pkg/cmd/generate/mock_test.go
+++ b/pkg/cmd/generate/mock_test.go
@@ -26,8 +26,8 @@ func newDefaultFiles(t *testing.T, fakeFiles ...test.FakeFileCreator) assets.FS
 
 	files := test.NewFakeFiles(t,
 		append(fakeFiles,
-			test.FakeTemplate("setup/roles/host.yaml", roles...),
-			test.FakeTemplate("setup/roles/member.yaml", roles...))...,
+			test.FakeTemplate("roles/host.yaml", roles...),
+			test.FakeTemplate("roles/member.yaml", roles...))...,
 	)
 	return files
 }
@@ -41,23 +41,23 @@ func createKubeSawAdminsFile(t *testing.T, dirPrefix string, content []byte) str
 	return configFile
 }
 
-// setupContext part
+// adminManifestsContext part
 
-func newSetupContextWithDefaultFiles(t *testing.T, config *assets.KubeSawAdmins) *setupContext { //nolint:unparam
-	return newSetupContext(t, config, newDefaultFiles(t))
+func newAdminManifestsContextWithDefaultFiles(t *testing.T, config *assets.KubeSawAdmins) *adminManifestsContext { //nolint:unparam
+	return newAdminManifestsContext(t, config, newDefaultFiles(t))
 }
 
-func newSetupContext(t *testing.T, config *assets.KubeSawAdmins, files assets.FS) *setupContext {
+func newAdminManifestsContext(t *testing.T, config *assets.KubeSawAdmins, files assets.FS) *adminManifestsContext {
 	fakeTerminal := test.NewFakeTerminal()
 	fakeTerminal.Tee(os.Stdout)
 	require.NoError(t, client.AddToScheme())
 	temp, err := os.MkdirTemp("", "cli-tests-")
 	require.NoError(t, err)
-	return &setupContext{
+	return &adminManifestsContext{
 		Terminal:      fakeTerminal,
 		kubeSawAdmins: config,
 		files:         files,
-		setupFlags: setupFlags{
+		adminManifestsFlags: adminManifestsFlags{
 			outDir:        temp,
 			memberRootDir: "member",
 			hostRootDir:   "host",
@@ -67,9 +67,9 @@ func newSetupContext(t *testing.T, config *assets.KubeSawAdmins, files assets.FS
 
 // ClusterContext part
 
-func newFakeClusterContext(setupContext *setupContext, clusterType configuration.ClusterType) *clusterContext {
+func newFakeClusterContext(adminManifestsContext *adminManifestsContext, clusterType configuration.ClusterType) *clusterContext {
 	return &clusterContext{
-		setupContext: setupContext,
-		clusterType:  clusterType,
+		adminManifestsContext: adminManifestsContext,
+		clusterType:           clusterType,
 	}
 }
diff --git a/pkg/cmd/generate/permissions_test.go b/pkg/cmd/generate/permissions_test.go
index cabac7b..8f1da36 100644
--- a/pkg/cmd/generate/permissions_test.go
+++ b/pkg/cmd/generate/permissions_test.go
@@ -86,7 +86,7 @@ func TestEnsureServiceAccount(t *testing.T) {
 
 	t.Run("create SA", func(t *testing.T) {
 		// given
-		ctx := newFakeClusterContext(newSetupContextWithDefaultFiles(t, nil), configuration.Host)
+		ctx := newFakeClusterContext(newAdminManifestsContextWithDefaultFiles(t, nil), configuration.Host)
 		cache := objectsCache{}
 
 		// when
@@ -104,7 +104,7 @@ func TestEnsureServiceAccount(t *testing.T) {
 
 	t.Run("create SA in the given namespace", func(t *testing.T) {
 		// given
-		ctx := newFakeClusterContext(newSetupContextWithDefaultFiles(t, nil), configuration.Host)
+		ctx := newFakeClusterContext(newAdminManifestsContextWithDefaultFiles(t, nil), configuration.Host)
 		cache := objectsCache{}
 
 		// when
@@ -130,7 +130,7 @@ func TestEnsureUserAndIdentity(t *testing.T) {
 
 	t.Run("create user, multiple identity & groups", func(t *testing.T) {
 		// given
-		ctx := newFakeClusterContext(newSetupContextWithDefaultFiles(t, nil), configuration.Host)
+		ctx := newFakeClusterContext(newAdminManifestsContextWithDefaultFiles(t, nil), configuration.Host)
 		cache := objectsCache{}
 
 		// when
@@ -150,7 +150,7 @@ func TestEnsureUserAndIdentity(t *testing.T) {
 
 	t.Run("don't create any group", func(t *testing.T) {
 		// given
-		ctx := newFakeClusterContext(newSetupContextWithDefaultFiles(t, nil), configuration.Host)
+		ctx := newFakeClusterContext(newAdminManifestsContextWithDefaultFiles(t, nil), configuration.Host)
 		cache := objectsCache{}
 
 		// when
@@ -170,7 +170,7 @@ func TestEnsureGroupsForUser(t *testing.T) {
 
 	t.Run("when creating group(s)", func(t *testing.T) {
 		// given
-		ctx := newFakeClusterContext(newSetupContextWithDefaultFiles(t, nil), configuration.Host)
+		ctx := newFakeClusterContext(newAdminManifestsContextWithDefaultFiles(t, nil), configuration.Host)
 		cache := objectsCache{}
 
 		// when
@@ -196,7 +196,7 @@ func TestEnsureGroupsForUser(t *testing.T) {
 }
 
 func newPermissionsManager(t *testing.T, clusterType configuration.ClusterType, config *assets.KubeSawAdmins) (permissionsManager, *clusterContext) { // nolint:unparam
-	ctx := newSetupContextWithDefaultFiles(t, config)
+	ctx := newAdminManifestsContextWithDefaultFiles(t, config)
 	clusterCtx := newFakeClusterContext(ctx, clusterType)
 	cache := objectsCache{}
 
diff --git a/pkg/cmd/generate/roles_manager_test.go b/pkg/cmd/generate/roles_manager_test.go
index 3e24dd4..79880fb 100644
--- a/pkg/cmd/generate/roles_manager_test.go
+++ b/pkg/cmd/generate/roles_manager_test.go
@@ -24,9 +24,9 @@ var (
 func TestGetRole(t *testing.T) {
 	// given
 	files := NewFakeFiles(t,
-		FakeTemplate("setup/roles/host.yaml", installOperatorRole),
-		FakeTemplate("setup/roles/member.yaml", restartDeploymentRole, registerClusterRole))
-	ctx := newSetupContext(t, &assets.KubeSawAdmins{}, files)
+		FakeTemplate("roles/host.yaml", installOperatorRole),
+		FakeTemplate("roles/member.yaml", restartDeploymentRole, registerClusterRole))
+	ctx := newAdminManifestsContext(t, &assets.KubeSawAdmins{}, files)
 
 	t.Run("for host cluster type", func(t *testing.T) {
 		// given
@@ -89,12 +89,12 @@ func TestGetRole(t *testing.T) {
 func TestEnsureRole(t *testing.T) {
 	// given
 	files := NewFakeFiles(t,
-		FakeTemplate("setup/roles/host.yaml", installOperatorRole),
-		FakeTemplate("setup/roles/member.yaml", installOperatorRole, restartDeploymentRole, configureComponentRole, registerClusterRole))
+		FakeTemplate("roles/host.yaml", installOperatorRole),
+		FakeTemplate("roles/member.yaml", installOperatorRole, restartDeploymentRole, configureComponentRole, registerClusterRole))
 
 	t.Run("create install-operator role for host", func(t *testing.T) {
 		// given
-		ctx := newSetupContext(t, &assets.KubeSawAdmins{}, files)
+		ctx := newAdminManifestsContext(t, &assets.KubeSawAdmins{}, files)
 		hostCtx := newFakeClusterContext(ctx, configuration.Host)
 		memberCtx := newFakeClusterContext(ctx, configuration.Member)
 		cache := objectsCache{}
@@ -155,7 +155,7 @@ func TestEnsureRole(t *testing.T) {
 
 	t.Run("create restart-deployment role for member", func(t *testing.T) {
 		// given
-		ctx := newSetupContext(t, &assets.KubeSawAdmins{}, files)
+		ctx := newAdminManifestsContext(t, &assets.KubeSawAdmins{}, files)
 		memberCtx := newFakeClusterContext(ctx, configuration.Member)
 		cache := objectsCache{}
 
diff --git a/pkg/cmd/generate/util.go b/pkg/cmd/generate/util.go
index 94fdffe..65a1d04 100644
--- a/pkg/cmd/generate/util.go
+++ b/pkg/cmd/generate/util.go
@@ -63,7 +63,7 @@ func (c objectsCache) ensureObject(ctx *clusterContext, toEnsure runtimeclient.O
 	return nil
 }
 
-func (c objectsCache) writeManifests(ctx *setupContext) error {
+func (c objectsCache) writeManifests(ctx *adminManifestsContext) error {
 	for path, object := range c {
 		if err := writeManifest(ctx, path, object); err != nil {
 			return err
@@ -72,7 +72,7 @@ func (c objectsCache) writeManifests(ctx *setupContext) error {
 	return nil
 }
 
-func writeManifest(ctx *setupContext, filePath string, obj runtimeclient.Object) error {
+func writeManifest(ctx *adminManifestsContext, filePath string, obj runtimeclient.Object) error {
 	dirPath := filepath.Dir(filePath)
 	if err := os.MkdirAll(dirPath, 0744); err != nil {
 		return err
@@ -102,14 +102,14 @@ func filePaths(ctx *clusterContext, obj runtimeclient.Object) (string, string, s
 		return "", "", "", fmt.Errorf("missing name in the manifest of the type %s", reflect.TypeOf(obj).Elem().Name())
 	}
 
-	defaultPath := filePath(rootDir(ctx.setupContext, ctx.clusterType), obj, plural.Resource)
-	theOtherTypePath := filePath(rootDir(ctx.setupContext, ctx.clusterType.TheOtherType()), obj, plural.Resource)
+	defaultPath := filePath(rootDir(ctx.adminManifestsContext, ctx.clusterType), obj, plural.Resource)
+	theOtherTypePath := filePath(rootDir(ctx.adminManifestsContext, ctx.clusterType.TheOtherType()), obj, plural.Resource)
 	basePath := filePath(baseDirectory(ctx.outDir), obj, plural.Resource)
 
 	return defaultPath, theOtherTypePath, basePath, nil
 }
 
-func rootDir(ctx *setupContext, clusterType configuration.ClusterType) string {
+func rootDir(ctx *adminManifestsContext, clusterType configuration.ClusterType) string {
 	if clusterType == configuration.Host {
 		return filepath.Join(ctx.outDir, ctx.hostRootDir)
 	}
@@ -145,7 +145,7 @@ func baseDirectory(outDir string) string {
 	return filepath.Join(outDir, "base")
 }
 
-func ensureKustomization(ctx *setupContext, dirPath, item string) error {
+func ensureKustomization(ctx *adminManifestsContext, dirPath, item string) error {
 	kustomization := &ktypes.Kustomization{
 		TypeMeta: ktypes.TypeMeta{
 			APIVersion: ktypes.KustomizationVersion,
diff --git a/pkg/cmd/generate/util_test.go b/pkg/cmd/generate/util_test.go
index 909b754..f165ef5 100644
--- a/pkg/cmd/generate/util_test.go
+++ b/pkg/cmd/generate/util_test.go
@@ -52,7 +52,7 @@ func verifyEnsureManifest(t *testing.T, clusterType configuration.ClusterType, o
 	for _, namespace := range []string{"johnspace", "second-namespace", ""} {
 		t.Run("for namespace "+namespace, func(t *testing.T) {
 			// given
-			ctx := newSetupContextWithDefaultFiles(t, nil)
+			ctx := newAdminManifestsContextWithDefaultFiles(t, nil)
 			cache := objectsCache{}
 			toBeStored, expected := prepareObjects(t, "john", namespace, object)
 
@@ -141,8 +141,8 @@ func verifyEnsureManifest(t *testing.T, clusterType configuration.ClusterType, o
 
 				t.Run("single-cluster mode enabled", func(t *testing.T) {
 					// given
-					ctx := newSetupContextWithDefaultFiles(t, nil)
-					ctx.setupFlags.singleCluster = true
+					ctx := newAdminManifestsContextWithDefaultFiles(t, nil)
+					ctx.adminManifestsFlags.singleCluster = true
 
 					t.Run("update after move to base", func(t *testing.T) {
 						// given
@@ -243,7 +243,7 @@ func verifyUpdates(t *testing.T, ctx *clusterContext, cache objectsCache, object
 
 func TestWriteManifests(t *testing.T) {
 	// given
-	ctx := newSetupContextWithDefaultFiles(t, nil)
+	ctx := newAdminManifestsContextWithDefaultFiles(t, nil)
 	cache := objectsCache{}
 	for _, clusterType := range configuration.ClusterTypes {
 		for _, namespace := range []string{"johnspace", "second-namespace", ""} {
@@ -277,7 +277,7 @@ func TestWriteManifest(t *testing.T) {
 	for _, rootDir := range []string{"host", "member", "base"} {
 		t.Run("for root dir "+rootDir, func(t *testing.T) {
 			// given
-			ctx := newSetupContextWithDefaultFiles(t, nil)
+			ctx := newAdminManifestsContextWithDefaultFiles(t, nil)
 			path := filepath.Join(ctx.outDir, rootDir, "test", "resource.yaml")
 			_, expectedObject := prepareObjects(t, "john", "john-comp", &corev1.ServiceAccount{})
 
diff --git a/resources/setup/roles/host.yaml b/resources/roles/host.yaml
similarity index 100%
rename from resources/setup/roles/host.yaml
rename to resources/roles/host.yaml
diff --git a/resources/setup/roles/member.yaml b/resources/roles/member.yaml
similarity index 100%
rename from resources/setup/roles/member.yaml
rename to resources/roles/member.yaml