diff --git a/packages/aws-cdk/bin/cdk.ts b/packages/aws-cdk/bin/cdk.ts
index cddbc5ff052e0..b629bb0ce9a27 100644
--- a/packages/aws-cdk/bin/cdk.ts
+++ b/packages/aws-cdk/bin/cdk.ts
@@ -6,14 +6,14 @@ import fs = require('fs-extra');
 import util = require('util');
 import yargs = require('yargs');
 
-import { bootstrapEnvironment, deployStack, destroyStack, loadToolkitInfo, SDK } from '../lib';
+import { bootstrapEnvironment, destroyStack, SDK } from '../lib';
 import { environmentsFromDescriptors, globEnvironmentsFromStacks } from '../lib/api/cxapp/environments';
 import { execProgram } from '../lib/api/cxapp/exec';
 import { AppStacks, ExtendedStackSelection, listStackNames } from '../lib/api/cxapp/stacks';
-import { CloudFormationDeploymentTarget } from '../lib/api/deployment-target';
+import { CloudFormationDeploymentTarget, DEFAULT_TOOLKIT_STACK_NAME } from '../lib/api/deployment-target';
 import { leftPad } from '../lib/api/util/string-manipulation';
 import { CdkToolkit } from '../lib/cdk-toolkit';
-import { printSecurityDiff, RequireApproval } from '../lib/diff';
+import { RequireApproval } from '../lib/diff';
 import { availableInitLanguages, cliInit, printAvailableTemplates } from '../lib/init';
 import { interactive } from '../lib/interactive';
 import { data, debug, error, highlight, print, setVerbose, success } from '../lib/logging';
@@ -27,8 +27,6 @@ import { VERSION } from '../lib/version';
 const promptly = require('promptly');
 const confirm = util.promisify(promptly.confirm);
 
-const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';
-
 // tslint:disable:no-shadowed-variable max-line-length
 async function parseCommandLineArguments() {
   const initTemplateLanuages = await availableInitLanguages;
@@ -61,6 +59,7 @@ async function parseCommandLineArguments() {
       .option('numbered', { type: 'boolean', alias: 'n', desc: 'prefix filenames with numbers to indicate deployment ordering' }))
     .command('bootstrap [ENVIRONMENTS..]', 'Deploys the CDK toolkit stack into an AWS environment')
     .command('deploy [STACKS..]', 'Deploys the stack(s) named STACKS into your AWS account', yargs => yargs
+      .option('build-exclude', { type: 'array', alias: 'E', nargs: 1, desc: 'do not rebuild asset with the given ID. Can be specified multiple times.', default: [] })
       .option('exclusively', { type: 'boolean', alias: 'e', desc: 'only deploy requested stacks, don\'t include dependencies' })
       .option('require-approval', { type: 'string', choices: [RequireApproval.Never, RequireApproval.AnyChange, RequireApproval.Broadening], desc: 'what security-sensitive changes need manual approval' }))
       .option('ci', { type: 'boolean', desc: 'Force CI detection. Use --no-ci to disable CI autodetection.', default: process.env.CI !== undefined })
@@ -87,6 +86,7 @@ async function parseCommandLineArguments() {
     ].join('\n\n'))
     .argv;
 }
+
 if (!process.stdout.isTTY) {
   colors.disable();
 }
@@ -191,7 +191,15 @@ async function initCommandLine() {
         return await cliBootstrap(args.ENVIRONMENTS, toolkitStackName, args.roleArn);
 
       case 'deploy':
-        return await cliDeploy(args.STACKS, args.exclusively, toolkitStackName, args.roleArn, configuration.settings.get(['requireApproval']), args.ci);
+        return await cli.deploy({
+          stackNames: args.STACKS,
+          exclusively: args.exclusively,
+          toolkitStackName,
+          roleArn: args.roleArn,
+          requireApproval: configuration.settings.get(['requireApproval']),
+          ci: args.ci,
+          reuseAssets: args['build-exclude']
+        });
 
       case 'destroy':
         return await cliDestroy(args.STACKS, args.exclusively, args.force, args.roleArn);
@@ -340,73 +348,6 @@ async function initCommandLine() {
     return 0; // exit-code
   }
 
-  async function cliDeploy(stackNames: string[],
-                           exclusively: boolean,
-                           toolkitStackName: string,
-                           roleArn: string | undefined,
-                           requireApproval: RequireApproval,
-                           ci: boolean) {
-    if (requireApproval === undefined) { requireApproval = RequireApproval.Broadening; }
-
-    const stacks = await appStacks.selectStacks(stackNames, exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Upstream);
-
-    for (const stack of stacks) {
-      if (stacks.length !== 1) { highlight(stack.name); }
-      if (!stack.environment) {
-        // tslint:disable-next-line:max-line-length
-        throw new Error(`Stack ${stack.name} does not define an environment, and AWS credentials could not be obtained from standard locations or no region was configured.`);
-      }
-      const toolkitInfo = await loadToolkitInfo(stack.environment, aws, toolkitStackName);
-
-      if (requireApproval !== RequireApproval.Never) {
-        const currentTemplate = await provisioner.readCurrentTemplate(stack);
-        if (printSecurityDiff(currentTemplate, stack, requireApproval)) {
-
-          // only talk to user if we STDIN is a terminal (otherwise, fail)
-          if (!process.stdin.isTTY) {
-            throw new Error(
-              '"--require-approval" is enabled and stack includes security-sensitive updates, ' +
-              'but terminal (TTY) is not attached so we are unable to get a confirmation from the user');
-          }
-
-          const confirmed = await confirm(`Do you wish to deploy these changes (y/n)?`);
-          if (!confirmed) { throw new Error('Aborted by user'); }
-        }
-      }
-
-      if (stack.name !== stack.originalName) {
-        print('%s: deploying... (was %s)', colors.bold(stack.name), colors.bold(stack.originalName));
-      } else {
-        print('%s: deploying...', colors.bold(stack.name));
-      }
-
-      try {
-        const result = await deployStack({ stack, sdk: aws, toolkitInfo, deployName: stack.name, roleArn, ci });
-        const message = result.noOp
-          ? ` ✅  %s (no changes)`
-          : ` ✅  %s`;
-
-        success('\n' + message, stack.name);
-
-        if (Object.keys(result.outputs).length > 0) {
-          print('\nOutputs:');
-        }
-
-        for (const name of Object.keys(result.outputs)) {
-          const value = result.outputs[name];
-          print('%s.%s = %s', colors.cyan(stack.name), colors.cyan(name), colors.underline(colors.cyan(value)));
-        }
-
-        print('\nStack ARN:');
-
-        data(result.stackArn);
-      } catch (e) {
-        error('\n ❌  %s failed: %s', colors.bold(stack.name), e);
-        throw e;
-      }
-    }
-  }
-
   async function cliDestroy(stackNames: string[], exclusively: boolean, force: boolean, roleArn: string | undefined) {
     const stacks = await appStacks.selectStacks(stackNames, exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Downstream);
 
diff --git a/packages/aws-cdk/lib/api/deploy-stack.ts b/packages/aws-cdk/lib/api/deploy-stack.ts
index 3ad0c95b8e0aa..d678505444d77 100644
--- a/packages/aws-cdk/lib/api/deploy-stack.ts
+++ b/packages/aws-cdk/lib/api/deploy-stack.ts
@@ -31,6 +31,7 @@ export interface DeployStackOptions {
   deployName?: string;
   quiet?: boolean;
   ci?: boolean;
+  reuseAssets?: string[];
 }
 
 const LARGE_TEMPLATE_SIZE_KB = 50;
@@ -40,7 +41,7 @@ export async function deployStack(options: DeployStackOptions): Promise<DeploySt
     throw new Error(`The stack ${options.stack.name} does not have an environment`);
   }
 
-  const params = await prepareAssets(options.stack, options.toolkitInfo, options.ci);
+  const params = await prepareAssets(options.stack, options.toolkitInfo, options.ci, options.reuseAssets);
 
   const deployName = options.deployName || options.stack.name;
 
diff --git a/packages/aws-cdk/lib/api/deployment-target.ts b/packages/aws-cdk/lib/api/deployment-target.ts
index 53c004184b897..61dc56458fc42 100644
--- a/packages/aws-cdk/lib/api/deployment-target.ts
+++ b/packages/aws-cdk/lib/api/deployment-target.ts
@@ -2,8 +2,12 @@ import cxapi = require('@aws-cdk/cx-api');
 import { debug } from '../logging';
 import { deserializeStructure } from '../serialize';
 import { Mode } from './aws-auth/credentials';
+import { deployStack, DeployStackResult } from './deploy-stack';
+import { loadToolkitInfo } from './toolkit-info';
 import { SDK } from './util/sdk';
 
+export const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';
+
 export type Template = { [key: string]: any };
 
 /**
@@ -13,6 +17,17 @@ export type Template = { [key: string]: any };
  */
 export interface IDeploymentTarget {
   readCurrentTemplate(stack: cxapi.SynthesizedStack): Promise<Template>;
+  deployStack(options: DeployStackOptions): Promise<DeployStackResult>;
+}
+
+export interface DeployStackOptions {
+  stack: cxapi.SynthesizedStack;
+  roleArn?: string;
+  deployName?: string;
+  quiet?: boolean;
+  ci?: boolean;
+  toolkitStackName?: string;
+  reuseAssets?: string[];
 }
 
 export interface ProvisionerProps {
@@ -23,13 +38,16 @@ export interface ProvisionerProps {
  * Default provisioner (applies to CloudFormation).
  */
 export class CloudFormationDeploymentTarget implements IDeploymentTarget {
-  constructor(private readonly props: ProvisionerProps) {
+  private readonly aws: SDK;
+
+  constructor(props: ProvisionerProps) {
+    this.aws = props.aws;
   }
 
   public async readCurrentTemplate(stack: cxapi.SynthesizedStack): Promise<Template> {
     debug(`Reading existing template for stack ${stack.name}.`);
 
-    const cfn = await this.props.aws.cloudFormation(stack.environment, Mode.ForReading);
+    const cfn = await this.aws.cloudFormation(stack.environment, Mode.ForReading);
     try {
       const response = await cfn.getTemplate({ StackName: stack.name }).promise();
       return (response.TemplateBody && deserializeStructure(response.TemplateBody)) || {};
@@ -41,4 +59,18 @@ export class CloudFormationDeploymentTarget implements IDeploymentTarget {
       }
     }
   }
+
+  public async deployStack(options: DeployStackOptions): Promise<DeployStackResult> {
+    const toolkitInfo = await loadToolkitInfo(options.stack.environment, this.aws, options.toolkitStackName || DEFAULT_TOOLKIT_STACK_NAME);
+    return deployStack({
+      stack: options.stack,
+      deployName: options.deployName,
+      roleArn: options.roleArn,
+      quiet: options.quiet,
+      sdk: this.aws,
+      ci: options.ci,
+      reuseAssets: options.reuseAssets,
+      toolkitInfo,
+    });
+  }
 }
\ No newline at end of file
diff --git a/packages/aws-cdk/lib/assets.ts b/packages/aws-cdk/lib/assets.ts
index 5b4f1a8cdb1de..5ea3de78d726e 100644
--- a/packages/aws-cdk/lib/assets.ts
+++ b/packages/aws-cdk/lib/assets.ts
@@ -10,8 +10,11 @@ import { zipDirectory } from './archive';
 import { prepareContainerAsset } from './docker';
 import { debug, success } from './logging';
 
-export async function prepareAssets(stack: SynthesizedStack, toolkitInfo?: ToolkitInfo, ci?: boolean): Promise<CloudFormation.Parameter[]> {
+// tslint:disable-next-line:max-line-length
+export async function prepareAssets(stack: SynthesizedStack, toolkitInfo?: ToolkitInfo, ci?: boolean, reuse?: string[]): Promise<CloudFormation.Parameter[]> {
+  reuse = reuse || [];
   const assets = findAssets(stack.metadata);
+
   if (assets.length === 0) {
     return [];
   }
@@ -21,40 +24,51 @@ export async function prepareAssets(stack: SynthesizedStack, toolkitInfo?: Toolk
     throw new Error(`This stack uses assets, so the toolkit stack must be deployed to the environment (Run "${colors.blue("cdk bootstrap " + stack.environment!.name)}")`);
   }
 
-  debug('Preparing assets');
   let params = new Array<CloudFormation.Parameter>();
   for (const asset of assets) {
-    debug(` - ${asset.path} (${asset.packaging})`);
+    // FIXME: Should have excluded by construct path here instead of by unique ID, preferably using
+    // minimatch so we can support globs. Maybe take up during artifact refactoring.
+    const reuseAsset = reuse.indexOf(asset.id) > -1;
+
+    if (reuseAsset) {
+      debug(`Preparing asset ${asset.id}: ${JSON.stringify(asset)} (reusing)`);
+    } else {
+      debug(`Preparing asset ${asset.id}: ${JSON.stringify(asset)}`);
+    }
 
-    params = params.concat(await prepareAsset(asset, toolkitInfo, ci));
+    params = params.concat(await prepareAsset(asset, toolkitInfo, reuseAsset, ci));
   }
 
   return params;
 }
 
-async function prepareAsset(asset: AssetMetadataEntry, toolkitInfo: ToolkitInfo, ci?: boolean): Promise<CloudFormation.Parameter[]> {
-  debug('Preparing asset', JSON.stringify(asset));
+// tslint:disable-next-line:max-line-length
+async function prepareAsset(asset: AssetMetadataEntry, toolkitInfo: ToolkitInfo, reuse: boolean, ci?: boolean): Promise<CloudFormation.Parameter[]> {
   switch (asset.packaging) {
     case 'zip':
-      return await prepareZipAsset(asset, toolkitInfo);
+      return await prepareZipAsset(asset, toolkitInfo, reuse);
     case 'file':
-      return await prepareFileAsset(asset, toolkitInfo);
+      return await prepareFileAsset(asset, toolkitInfo, reuse);
     case 'container-image':
-      return await prepareContainerAsset(asset, toolkitInfo, ci);
+      return await prepareContainerAsset(asset, toolkitInfo, reuse, ci);
     default:
       // tslint:disable-next-line:max-line-length
       throw new Error(`Unsupported packaging type: ${(asset as any).packaging}. You might need to upgrade your aws-cdk toolkit to support this asset type.`);
   }
 }
 
-async function prepareZipAsset(asset: FileAssetMetadataEntry, toolkitInfo: ToolkitInfo): Promise<CloudFormation.Parameter[]> {
+async function prepareZipAsset(asset: FileAssetMetadataEntry, toolkitInfo: ToolkitInfo, reuse: boolean): Promise<CloudFormation.Parameter[]> {
+  if (reuse) {
+    return await prepareFileAsset(asset, toolkitInfo, reuse);
+  }
+
   debug('Preparing zip asset from directory:', asset.path);
   const staging = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-assets'));
   try {
     const archiveFile = path.join(staging, 'archive.zip');
     await zipDirectory(asset.path, archiveFile);
     debug('zip archive:', archiveFile);
-    return await prepareFileAsset(asset, toolkitInfo, archiveFile, 'application/zip');
+    return await prepareFileAsset(asset, toolkitInfo, reuse, archiveFile, 'application/zip');
   } finally {
     await fs.remove(staging);
   }
@@ -69,9 +83,17 @@ async function prepareZipAsset(asset: FileAssetMetadataEntry, toolkitInfo: Toolk
 async function prepareFileAsset(
     asset: FileAssetMetadataEntry,
     toolkitInfo: ToolkitInfo,
+    reuse: boolean,
     filePath?: string,
     contentType?: string): Promise<CloudFormation.Parameter[]> {
 
+  if (reuse) {
+    return [
+      { ParameterKey: asset.s3BucketParameter, UsePreviousValue: true },
+      { ParameterKey: asset.s3KeyParameter, UsePreviousValue: true },
+    ];
+  }
+
   filePath = filePath || asset.path;
   debug('Preparing file asset:', filePath);
 
diff --git a/packages/aws-cdk/lib/cdk-toolkit.ts b/packages/aws-cdk/lib/cdk-toolkit.ts
index 59461ab1dff76..1aad96c3b8b81 100644
--- a/packages/aws-cdk/lib/cdk-toolkit.ts
+++ b/packages/aws-cdk/lib/cdk-toolkit.ts
@@ -1,11 +1,16 @@
 import colors = require('colors/safe');
 import fs = require('fs-extra');
-import { format } from 'util';
+import { format, promisify } from 'util';
 import { AppStacks, ExtendedStackSelection } from "./api/cxapp/stacks";
 import { IDeploymentTarget } from './api/deployment-target';
-import { printStackDiff } from './diff';
+import { printSecurityDiff, printStackDiff, RequireApproval } from './diff';
+import { data, error, highlight, print, success } from './logging';
 import { deserializeStructure } from './serialize';
 
+// tslint:disable-next-line:no-var-requires
+const promptly = require('promptly');
+const confirm = promisify(promptly.confirm);
+
 export interface CdkToolkitProps {
   /**
    * The (stacks of the) CDK application
@@ -25,11 +30,16 @@ export interface CdkToolkitProps {
  * object and applies them to the `provisioner`.
  */
 export class CdkToolkit {
-  constructor(private readonly props: CdkToolkitProps) {
+  private readonly appStacks: AppStacks;
+  private readonly provisioner: IDeploymentTarget;
+
+  constructor(props: CdkToolkitProps) {
+    this.appStacks = props.appStacks;
+    this.provisioner = props.provisioner;
   }
 
   public async diff(options: DiffOptions): Promise<number> {
-    const stacks = await this.props.appStacks.selectStacks(
+    const stacks = await this.appStacks.selectStacks(
       options.stackNames,
       options.exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Upstream);
 
@@ -53,7 +63,7 @@ export class CdkToolkit {
       // Compare N stacks against deployed templates
       for (const stack of stacks) {
         stream.write(format('Stack %s\n', colors.bold(stack.name)));
-        const currentTemplate = await this.props.provisioner.readCurrentTemplate(stack);
+        const currentTemplate = await this.provisioner.readCurrentTemplate(stack);
         if (printStackDiff(currentTemplate, stack, !!options.strict, options.contextLines || 3, stream) !== 0) {
           ret = 1;
         }
@@ -62,6 +72,77 @@ export class CdkToolkit {
 
     return ret;
   }
+
+  public async deploy(options: DeployOptions) {
+    const requireApproval = options.requireApproval !== undefined ? options.requireApproval : RequireApproval.Broadening;
+
+    const stacks = await this.appStacks.selectStacks(
+      options.stackNames,
+      options.exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Upstream);
+
+    for (const stack of stacks) {
+      if (stacks.length !== 1) { highlight(stack.name); }
+      if (!stack.environment) {
+        // tslint:disable-next-line:max-line-length
+        throw new Error(`Stack ${stack.name} does not define an environment, and AWS credentials could not be obtained from standard locations or no region was configured.`);
+      }
+
+      if (requireApproval !== RequireApproval.Never) {
+        const currentTemplate = await this.provisioner.readCurrentTemplate(stack);
+        if (printSecurityDiff(currentTemplate, stack, requireApproval)) {
+
+          // only talk to user if STDIN is a terminal (otherwise, fail)
+          if (!process.stdin.isTTY) {
+            throw new Error(
+              '"--require-approval" is enabled and stack includes security-sensitive updates, ' +
+              'but terminal (TTY) is not attached so we are unable to get a confirmation from the user');
+          }
+
+          const confirmed = await confirm(`Do you wish to deploy these changes (y/n)?`);
+          if (!confirmed) { throw new Error('Aborted by user'); }
+        }
+      }
+
+      if (stack.name !== stack.originalName) {
+        print('%s: deploying... (was %s)', colors.bold(stack.name), colors.bold(stack.originalName));
+      } else {
+        print('%s: deploying...', colors.bold(stack.name));
+      }
+
+      try {
+        const result = await this.provisioner.deployStack({
+          stack,
+          deployName: stack.name,
+          roleArn: options.roleArn,
+          ci: options.ci,
+          toolkitStackName: options.toolkitStackName,
+          reuseAssets: options.reuseAssets,
+        });
+
+        const message = result.noOp
+          ? ` ✅  %s (no changes)`
+          : ` ✅  %s`;
+
+        success('\n' + message, stack.name);
+
+        if (Object.keys(result.outputs).length > 0) {
+          print('\nOutputs:');
+        }
+
+        for (const name of Object.keys(result.outputs)) {
+          const value = result.outputs[name];
+          print('%s.%s = %s', colors.cyan(stack.name), colors.cyan(name), colors.underline(colors.cyan(value)));
+        }
+
+        print('\nStack ARN:');
+
+        data(result.stackArn);
+      } catch (e) {
+        error('\n ❌  %s failed: %s', colors.bold(stack.name), e);
+        throw e;
+      }
+    }
+  }
 }
 
 export interface DiffOptions {
@@ -105,3 +186,48 @@ export interface DiffOptions {
    */
   stream?: NodeJS.WritableStream;
 }
+
+export interface DeployOptions {
+  /**
+   * Stack names to deploy
+   */
+  stackNames: string[];
+
+  /**
+   * Only select the given stack
+   *
+   * @default false
+   */
+  exclusively?: boolean;
+
+  /**
+   * Name of the toolkit stack to use/deploy
+   *
+   * @default CDKToolkit
+   */
+  toolkitStackName?: string;
+
+  /**
+   * Role to pass to CloudFormation for deployment
+   */
+  roleArn?: string;
+
+  /**
+   * What kind of security changes require approval
+   *
+   * @default RequireApproval.Broadening
+   */
+  requireApproval?: RequireApproval;
+
+  /**
+   * Wheter we're in CI mode
+   *
+   * @default false
+   */
+  ci?: boolean;
+
+  /**
+   * Reuse the assets with the given asset IDs
+   */
+  reuseAssets?: string[];
+}
\ No newline at end of file
diff --git a/packages/aws-cdk/lib/docker.ts b/packages/aws-cdk/lib/docker.ts
index 98773bd61143b..2038276373638 100644
--- a/packages/aws-cdk/lib/docker.ts
+++ b/packages/aws-cdk/lib/docker.ts
@@ -30,10 +30,18 @@ import { PleaseHold } from './util/please-hold';
  */
 export async function prepareContainerAsset(asset: ContainerImageAssetMetadataEntry,
                                             toolkitInfo: ToolkitInfo,
+                                            reuse: boolean,
                                             ci?: boolean): Promise<CloudFormation.Parameter[]> {
+
+  if (reuse) {
+    return [
+      { ParameterKey: asset.imageNameParameter, UsePreviousValue: true },
+    ];
+  }
+
   debug(' 👑  Preparing Docker image asset:', asset.path);
 
-  const buildHold = new PleaseHold(` ⌛ Building Docker image for ${asset.path}; this may take a while.`);
+  const buildHold = new PleaseHold(` ⌛ Building Asset Docker image ${asset.id} from ${asset.path}; this may take a while.`);
   try {
     const ecr = await toolkitInfo.prepareEcrRepository(asset.id);
     const latest = `${ecr.repositoryUri}:latest`;
diff --git a/packages/aws-cdk/lib/settings.ts b/packages/aws-cdk/lib/settings.ts
index 434b1a96f8370..0ba8383750e5b 100644
--- a/packages/aws-cdk/lib/settings.ts
+++ b/packages/aws-cdk/lib/settings.ts
@@ -186,7 +186,7 @@ export class Settings {
     const context: any = {};
 
     // Turn list of KEY=VALUE strings into an object
-    for (const assignment of (argv.context || [])) {
+    for (const assignment of ((argv as any).context || [])) {
       const parts = assignment.split('=', 2);
       if (parts.length === 2) {
         debug('CLI argument context: %s=%s', parts[0], parts[1]);
diff --git a/packages/aws-cdk/package-lock.json b/packages/aws-cdk/package-lock.json
index 50c201d5fbbe2..f5c751b33620e 100644
--- a/packages/aws-cdk/package-lock.json
+++ b/packages/aws-cdk/package-lock.json
@@ -1,6 +1,6 @@
 {
 	"name": "aws-cdk",
-	"version": "0.24.1",
+	"version": "0.25.0",
 	"lockfileVersion": 1,
 	"requires": true,
 	"dependencies": {
diff --git a/packages/aws-cdk/test/test.assets.ts b/packages/aws-cdk/test/test.assets.ts
index eb54d6463a5cf..ff1ec67a82bb5 100644
--- a/packages/aws-cdk/test/test.assets.ts
+++ b/packages/aws-cdk/test/test.assets.ts
@@ -1,4 +1,4 @@
-import { AssetMetadataEntry, SynthesizedStack } from '@aws-cdk/cx-api';
+import { AssetMetadataEntry, ContainerImageAssetMetadataEntry, SynthesizedStack } from '@aws-cdk/cx-api';
 import { Test } from 'nodeunit';
 import { Uploaded, UploadProps } from '../lib';
 import { prepareAssets } from '../lib/assets';
@@ -14,25 +14,25 @@ export = {
         region: 'myregion'
       },
       metadata: {
-      '/SomeStack/SomeResource': [{
-        type: 'aws:cdk:asset',
-        data: {
-        path: __filename,
-        id: 'SomeStackSomeResource4567',
-        packaging: 'file',
-        s3BucketParameter: 'BucketParameter',
-        s3KeyParameter: 'KeyParameter'
-        } as AssetMetadataEntry,
-        trace: []
-      }]
+        '/SomeStack/SomeResource': [{
+          type: 'aws:cdk:asset',
+          data: {
+            path: __filename,
+            id: 'SomeStackSomeResource4567',
+            packaging: 'file',
+            s3BucketParameter: 'BucketParameter',
+            s3KeyParameter: 'KeyParameter'
+          } as AssetMetadataEntry,
+          trace: []
+        }]
       },
       template: {
-      Resources: {
-        SomeResource: {
-        Type: 'AWS::Something::Something'
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something::Something'
+          }
         }
       }
-      }
     };
     const toolkit = new FakeToolkit();
 
@@ -45,6 +45,88 @@ export = {
       { ParameterKey: 'KeyParameter', ParameterValue: 'assets/SomeStackSomeResource4567/||12345.js' },
     ]);
 
+    test.done();
+  },
+
+  async 'prepare assets with reuse'(test: Test) {
+    // GIVEN
+    const stack: SynthesizedStack = {
+      name: 'SomeStack',
+      environment: {
+        name: 'myenv',
+        account: 'myaccount',
+        region: 'myregion'
+      },
+      metadata: {
+        '/SomeStack/SomeResource': [{
+          type: 'aws:cdk:asset',
+          data: {
+            path: __filename,
+            id: 'SomeStackSomeResource4567',
+            packaging: 'file',
+            s3BucketParameter: 'BucketParameter',
+            s3KeyParameter: 'KeyParameter'
+          } as AssetMetadataEntry,
+          trace: []
+        }]
+      },
+      template: {
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something::Something'
+          }
+        }
+      }
+    };
+    const toolkit = new FakeToolkit();
+
+    // WHEN
+    const params = await prepareAssets(stack, toolkit as any, undefined, ['SomeStackSomeResource4567']);
+
+    // THEN
+    test.deepEqual(params, [
+      { ParameterKey: 'BucketParameter', UsePreviousValue: true },
+      { ParameterKey: 'KeyParameter', UsePreviousValue: true },
+    ]);
+
+    test.done();
+  },
+
+  async 'prepare container asset with reuse'(test: Test) {
+    // GIVEN
+    const stack: SynthesizedStack = {
+      name: 'SomeStack',
+      environment: { name: 'myenv', account: 'myaccount', region: 'myregion' },
+      metadata: {
+        '/SomeStack/SomeResource': [{
+          type: 'aws:cdk:asset',
+          data: {
+            path: __dirname,
+            id: 'SomeStackSomeResource4567',
+            packaging: 'container-image',
+            imageNameParameter: 'asdf'
+          } as ContainerImageAssetMetadataEntry,
+          trace: []
+        }]
+      },
+      template: {
+        Resources: {
+          SomeResource: {
+            Type: 'AWS::Something::Something'
+          }
+        }
+      }
+    };
+    const toolkit = new FakeToolkit();
+
+    // WHEN
+    const params = await prepareAssets(stack, toolkit as any, undefined, ['SomeStackSomeResource4567']);
+
+    // THEN
+    test.deepEqual(params, [
+      { ParameterKey: 'asdf', UsePreviousValue: true },
+    ]);
+
     test.done();
   }
 };
diff --git a/packages/aws-cdk/test/test.diff.ts b/packages/aws-cdk/test/test.diff.ts
index aaca613c6e45a..04a6818cd745c 100644
--- a/packages/aws-cdk/test/test.diff.ts
+++ b/packages/aws-cdk/test/test.diff.ts
@@ -2,6 +2,7 @@ import cxapi = require('@aws-cdk/cx-api');
 import { Test } from 'nodeunit';
 import { Writable } from 'stream';
 import { NodeStringDecoder, StringDecoder  } from 'string_decoder';
+import { DeployStackOptions, DeployStackResult } from '../lib';
 import { AppStacks } from '../lib/api/cxapp/stacks';
 import { IDeploymentTarget, Template } from '../lib/api/deployment-target';
 import { SDK } from '../lib/api/util/sdk';
@@ -39,6 +40,9 @@ export = {
     const provisioner: IDeploymentTarget = {
       async readCurrentTemplate(_stack: cxapi.SynthesizedStack): Promise<Template> {
         return {};
+      },
+      async deployStack(_options: DeployStackOptions): Promise<DeployStackResult> {
+        return { noOp: true, outputs: {}, stackArn: ''};
       }
     };
     const toolkit = new CdkToolkit({ appStacks, provisioner });