diff --git a/README.md b/README.md
index ae4d1b89..9d8b0087 100644
--- a/README.md
+++ b/README.md
@@ -100,7 +100,7 @@ $ npm install -g @devcycle/cli
 $ dvc COMMAND
 running command...
 $ dvc (--version)
-@devcycle/cli/5.11.1 linux-x64 node-v18.16.0
+@devcycle/cli/5.11.1 darwin-x64 node-v16.20.0
 $ dvc --help [COMMAND]
 USAGE
   $ dvc COMMAND
diff --git a/docs/variables.md b/docs/variables.md
index 2b09a0e9..0835b8cd 100644
--- a/docs/variables.md
+++ b/docs/variables.md
@@ -17,7 +17,7 @@ Create a new Variable for an existing Feature.
 USAGE
   $ dvc variables create [--config-path <value>] [--auth-path <value>] [--repo-config-path <value>] [--client-id
     <value>] [--client-secret <value>] [--project <value>] [--no-api] [--headless] [--key <value>] [--name <value>]
-    [--type String|Boolean|Number|JSON] [--feature <value>] [--description <value>]
+    [--type String|Boolean|Number|JSON] [--feature <value>] [--variations <value>] [--description <value>]
 
 FLAGS
   --description=<value>  Description for the dashboard
@@ -26,6 +26,8 @@ FLAGS
   --name=<value>         Human readable name
   --type=<option>        The type of variable
                          <options: String|Boolean|Number|JSON>
+  --variations=<value>   Set a value for this variable in each variation of the associated feature. Should be a JSON
+                         object with the keys being variation keys.
 
 GLOBAL FLAGS
   --auth-path=<value>         Override the default location to look for an auth.yml file
diff --git a/oclif.manifest.json b/oclif.manifest.json
index e3eab535..08a0d1ca 100644
--- a/oclif.manifest.json
+++ b/oclif.manifest.json
@@ -1,5 +1,5 @@
 {
-  "version": "5.11.0",
+  "version": "5.11.1",
   "commands": {
     "authCommand": {
       "id": "authCommand",
@@ -4731,6 +4731,12 @@
           "description": "The key or id of the feature to create the variable for",
           "multiple": false
         },
+        "variations": {
+          "name": "variations",
+          "type": "option",
+          "description": "Set a value for this variable in each variation of the associated feature. Should be a JSON object with the keys being variation keys.",
+          "multiple": false
+        },
         "description": {
           "name": "description",
           "type": "option",
diff --git a/src/api/zodClient.ts b/src/api/zodClient.ts
index dc56b14b..045522c7 100644
--- a/src/api/zodClient.ts
+++ b/src/api/zodClient.ts
@@ -444,9 +444,9 @@ const Feature = z.object({
     _createdBy: z.string().optional(),
     createdAt: z.string().datetime(),
     updatedAt: z.string().datetime(),
-    variations: z.array(Variation).optional(),
+    variations: z.array(Variation),
     controlVariation: z.string(),
-    variables: z.array(Variable).optional(),
+    variables: z.array(Variable),
     tags: z.array(z.string()).optional(),
     ldLink: z.string().optional(),
     readonly: z.boolean(),
diff --git a/src/commands/variables/create.test.ts b/src/commands/variables/create.test.ts
index 2106590b..a7b322db 100644
--- a/src/commands/variables/create.test.ts
+++ b/src/commands/variables/create.test.ts
@@ -25,20 +25,43 @@ describe('variables create', () => {
         'createdAt': '2023-06-14T18:56:21.270Z',
         'updatedAt': '2023-06-14T18:56:21.270Z'
     }
+    const mockFeature = {
+        'key': 'spam',
+        'variables': [
+            {
+                '_feature': featureId,
+                'key': mockVariable.key,
+                'type': mockVariable.type,
+                'name': mockVariable.name
+            }
+        ],
+        'variations': [
+            {
+                'key': 'variation-on',
+                'name': 'Variation On',
+                'variables': {
+                    'spam': 'ayyy',
+                }
+            },
+            {
+                'key': 'variation-off',
+                'name': 'Variation Off',
+                'variables': {
+                    'spam': 'lmao',
+                }
+            }
+        ]
+    }
     // Headless mode
     dvcTest()
         .nock(BASE_URL, (api) => api
-            .post(`/v1/projects/${projectKey}/variables`, {
-                ...requestBody,
-                _feature: featureId
-            })
+            .post(`/v1/projects/${projectKey}/variables`, requestBody)
             .reply(200, mockVariable)
         )
         .stdout()
         .command([
             'variables create',
             '--project', projectKey,
-            '--feature', featureId,
             '--type', requestBody.type,
             '--name', requestBody.name,
             '--key', requestBody.key,
@@ -49,20 +72,19 @@ describe('variables create', () => {
             (ctx) => {
                 expect(JSON.parse(ctx.stdout)).to.eql(mockVariable)
             })
-    
+
     dvcTest()
         .stderr()
         .command([
             'variables create',
             '--project', projectKey,
-            '--feature', featureId,
             '--type', requestBody.type,
             '--name', requestBody.name,
             '--headless',
             ...authFlags
         ])
         .it('Errors when called in headless mode with no key', (ctx) => {
-            expect(ctx.stderr).to.contain('The key, name, feature, and type flags are required')
+            expect(ctx.stderr).to.contain('The key, name, and type flags are required')
         })
 
     dvcTest()
@@ -88,31 +110,47 @@ describe('variables create', () => {
 
     dvcTest()
         .nock(BASE_URL, (api) => api
-            .post(`/v1/projects/${projectKey}/variables`, {
-                ...requestBody,
-                _feature: featureId
+            .get(`/v1/projects/${projectKey}/features/${featureId}`)
+            .reply(200, {
+                key: mockVariable.key,
+                _id: featureId,
+                variations: [
+                    {
+                        '_id': '64b05702053947be0d079ef3',
+                        'key': 'variation-on',
+                        'name': 'Variation On',
+                        'variables': {}
+                    },
+                    {
+                        '_id': '64b05702053947be0d079ef4',
+                        'key': 'variation-off',
+                        'name': 'Variation Off',
+                        'variables': {}
+                    }
+                ],
+                variables: []
             })
-            .reply(200, mockVariable)
+            .patch(`/v1/projects/${projectKey}/features/spam`, mockFeature)
+            .reply(200, mockFeature)
         )
-        .stub(inquirer, 'prompt', () => {
-            return { 
-                key: requestBody.key, 
-                description: undefined, 
-                associateToFeature: true, 
-                _feature: featureId
-            }
-        })
         .stdout()
         .command([
             'variables create',
             '--project', projectKey,
             '--type', requestBody.type,
+            '--key', requestBody.key,
             '--name', requestBody.name,
+            '--feature', featureId,
+            '--variations', '{"variation-on": "ayyy","variation-off": "lmao"}',
+            '--headless',
             ...authFlags
         ])
         .it('includes _feature in request when user selects to attach to a feature',
             (ctx) => {
-                expect(JSON.parse(ctx.stdout)).to.eql(mockVariable)
+                expect(ctx.stdout).to.contain(
+                    // eslint-disable-next-line max-len
+                    'The variable was associated to the existing feature spam. Use "dvc features get --keys=spam" to see its details'
+                )
             })
 
 })
diff --git a/src/commands/variables/create.ts b/src/commands/variables/create.ts
index d636efb0..d01e295e 100644
--- a/src/commands/variables/create.ts
+++ b/src/commands/variables/create.ts
@@ -3,9 +3,11 @@ import {
     createVariable,
 } from '../../api/variables'
 import CreateCommand from '../createCommand'
-import { createVariablePrompts, variableFeaturePrompt } from '../../ui/prompts'
-import { CreateVariableDto } from '../../api/schemas'
+import { createVariablePrompts, featurePrompt } from '../../ui/prompts'
+import { CreateVariableDto, Variable } from '../../api/schemas'
 import inquirer from '../../ui/autocomplete'
+import { VariableListOptions } from '../../ui/prompts/listPrompts/variablesListPrompt'
+import { fetchFeatureByKey, updateFeature } from '../../api/features'
 
 export default class CreateVariable extends CreateCommand {
     static hidden = false
@@ -20,6 +22,10 @@ export default class CreateVariable extends CreateCommand {
         'feature': Flags.string({
             description: 'The key or id of the feature to create the variable for'
         }),
+        'variations': Flags.string({
+            description: 'Set a value for this variable in each variation of the associated feature. ' +
+                'Should be a JSON object with the keys being variation keys.'
+        }),
         'description': Flags.string({
             description: 'Description for the dashboard',
         }),
@@ -29,16 +35,20 @@ export default class CreateVariable extends CreateCommand {
 
     public async run(): Promise<void> {
         const { flags } = await this.parse(CreateVariable)
-        const { key, name, type, feature, headless, project } = flags
+        const { key, name, type, feature, headless, project, variations } = flags
         await this.requireProject(project, headless)
 
-        if (headless && (!key || !name || !type || !feature)) {
-            this.writer.showError('The key, name, feature, and type flags are required')
+        if (headless && (!key || !name || !type)) {
+            this.writer.showError('The key, name, and type flags are required')
             return
         }
         flags._feature = feature
+        if (headless && variations && !flags._feature) {
+            this.writer.showError('Cannot modify variations without associating to a feature')
+            return
+        }
 
-        let params = await this.populateParametersWithZod(CreateVariableDto, this.prompts, flags)
+        const params = await this.populateParametersWithZod(CreateVariableDto, this.prompts, flags)
         if (!headless) {
             const { associateToFeature } = await inquirer.prompt([{
                 name: 'associateToFeature',
@@ -46,12 +56,52 @@ export default class CreateVariable extends CreateCommand {
                 type: 'confirm',
                 default: false
             }])
-    
+
             if (associateToFeature) {
-                params = await this.populateParametersWithZod(CreateVariableDto, [variableFeaturePrompt], params)
+                const { feature } = await inquirer.prompt([featurePrompt], {
+                    token: this.authToken,
+                    projectKey: this.projectKey
+                })
+                if (!feature) {
+                    this.writer.showError(`Feature with key ${feature.key} could not be found`)
+                    return
+                }
+                feature.variables.push(params)
+                const variableListOptions = new VariableListOptions(
+                    [params as Variable],
+                    this.writer,
+                    !variations ? feature.variations: undefined // don't prompt for variations if flag provided
+                )
+                await variableListOptions.promptVariationValues(params as Variable)
+                await updateFeature(this.authToken, this.projectKey, feature.key, feature)
+                const message = `The variable was associated to the existing feature ${feature.key}. ` +
+                    `Use "dvc features get --keys=${feature.key}" to see its details`
+                this.writer.successMessage(message)
+            } else {
+                const result = await createVariable(this.authToken, this.projectKey, params)
+                this.writer.showResults(result)
+            }
+        } else {
+            if (flags._feature) {
+                const feature = await fetchFeatureByKey(this.authToken, this.projectKey, flags._feature)
+                if (!feature) {
+                    this.writer.showError(`Feature with key ${flags._feature} could not be found`)
+                    return
+                }
+                const parsedVariations = JSON.parse(variations as string)
+                feature.variables.push(params as Variable)
+                for (const vari of feature.variations) {
+                    vari.variables = vari.variables || {}
+                    vari.variables[params.key] = parsedVariations[vari.key]
+                }
+                await updateFeature(this.authToken, this.projectKey, feature.key, feature)
+                const message = `The variable was associated to the existing feature ${feature.key}. ` +
+                `Use "dvc features get --keys=${feature.key}" to see its details.`
+                this.writer.showRawResults(message)
+            } else {
+                const result = await createVariable(this.authToken, this.projectKey, params)
+                this.writer.showResults(result)
             }
         }
-        const result = await createVariable(this.authToken, this.projectKey, params)
-        this.writer.showResults(result)
     }
 }
diff --git a/src/ui/prompts/listPrompts/variablesListPrompt.ts b/src/ui/prompts/listPrompts/variablesListPrompt.ts
index 629fd57b..f730fe9b 100644
--- a/src/ui/prompts/listPrompts/variablesListPrompt.ts
+++ b/src/ui/prompts/listPrompts/variablesListPrompt.ts
@@ -1,12 +1,12 @@
 import { createVariablePrompts, getVariableValuePrompt } from '../variablePrompts'
 import { ListOption, ListOptionsPrompt } from './listOptionsPrompt'
 import inquirer from 'inquirer'
-import { 
-    CreateVariableDto, 
-    CreateVariableParams, 
-    UpdateVariableDto, 
+import {
+    CreateVariableDto,
+    CreateVariableParams,
+    UpdateVariableDto,
     Variable,
-    Variation 
+    Variation
 } from '../../../api/schemas'
 import { errorMap } from '../../../api/apiClient'
 import Writer from '../../writer'
@@ -27,8 +27,8 @@ export class VariableListOptions extends ListOptionsPrompt<CreateVariableParams>
     }
 
     getVariablesListPrompt = () => ({
-        name: 'variables', 
-        value: 'variables', 
+        name: 'variables',
+        value: 'variables',
         message: 'Manage variables',
         type: 'listOptions',
         listOptionsPrompt: () => this.prompt(),
@@ -37,12 +37,12 @@ export class VariableListOptions extends ListOptionsPrompt<CreateVariableParams>
         )
     })
 
-    private async promptVariationValues(variable: Variable) {
+    async promptVariationValues(variable: Variable) {
         if (this.featureVariations?.length) {
             for (const variation of this.featureVariations) {
                 const variationPrompt = getVariableValuePrompt(
-                    variation, 
-                    variable.type, 
+                    variation,
+                    variable.type,
                     variation.variables?.[variable.key] as string | number | boolean
                 )
 
@@ -78,7 +78,7 @@ export class VariableListOptions extends ListOptionsPrompt<CreateVariableParams>
             type: 'list',
             choices: list
         }])
-        const index = list.findIndex((listItem) => (listItem.value.item.key === variableListItem.item.key)) 
+        const index = list.findIndex((listItem) => (listItem.value.item.key === variableListItem.item.key))
 
         // Have a default for each of the prompts that correspond to the previous value of the variable
         const filledOutPrompts = this.variablePropertyPrompts.map((prompt) => ({
@@ -101,7 +101,7 @@ export class VariableListOptions extends ListOptionsPrompt<CreateVariableParams>
     transformToListOptions(list: CreateVariableParams[]): ListOption<CreateVariableParams>[] {
         return list.map((createVariable, index) => ({
             name: createVariable.key,
-            value: { item: createVariable, id: index } 
+            value: { item: createVariable, id: index }
         }))
     }
 }