diff --git a/internal/tsetse/error_code.ts b/internal/tsetse/error_code.ts
index 87b7fd2..10d36c5 100644
--- a/internal/tsetse/error_code.ts
+++ b/internal/tsetse/error_code.ts
@@ -14,4 +14,5 @@
   PROPERTY_RENAMING_SAFE = 21227,
   CONFORMANCE_PATTERN = 21228,
   BAN_MUTABLE_EXPORTS = 21229,
+  BAN_STRING_INITIALIZED_SETS = 21230,
 }
diff --git a/internal/tsetse/rules/ban_string_initialized_sets_rule.ts b/internal/tsetse/rules/ban_string_initialized_sets_rule.ts
new file mode 100644
index 0000000..44087ba
--- /dev/null
+++ b/internal/tsetse/rules/ban_string_initialized_sets_rule.ts
@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Bans `new Set(<string>)` since it is a potential source of bugs
+ * due to strings also implementing `Iterable<string>`.
+ */
+
+import * as ts from 'typescript';
+
+import {Checker} from '../checker';
+import {ErrorCode} from '../error_code';
+import {AbstractRule} from '../rule';
+
+const errorMsg = 'Value passed to Set constructor is a string. This will' +
+    ' create a Set of the characters of the string, rather than a Set' +
+    ' containing the string. To make a Set of the string, pass an array' +
+    ' containing the string. To make a Set of the characters, use \'as\' to ' +
+    ' create an Iterable<string>, eg: new Set(myStr as Iterable<string>).';
+
+export class Rule extends AbstractRule {
+  readonly ruleName = 'ban-string-initialized-sets';
+  readonly code = ErrorCode.BAN_STRING_INITIALIZED_SETS;
+
+  register(checker: Checker) {
+    checker.on(ts.SyntaxKind.NewExpression, checkNewExpression, this.code);
+  }
+}
+
+function checkNewExpression(checker: Checker, node: ts.NewExpression) {
+  const typeChecker = checker.typeChecker;
+
+  // Check that it's a Set which is being constructed
+  const ctorTypeSymbol =
+      typeChecker.getTypeAtLocation(node.expression).getSymbol();
+
+  if (!ctorTypeSymbol || ctorTypeSymbol.getEscapedName() !== 'SetConstructor') {
+    return;
+  }
+  const isES2015SetCtor = ctorTypeSymbol.declarations.some((decl) => {
+    return sourceFileIsStdLib(decl.getSourceFile());
+  });
+  if (!isES2015SetCtor) return;
+
+  // If there's no arguments provided, then it's not a string so bail out.
+  if (!node.arguments || node.arguments.length !== 1) return;
+
+  // Check the type of the first argument, expanding union & intersection types
+  const arg = node.arguments[0];
+  const argType = typeChecker.getTypeAtLocation(arg);
+  const allTypes = argType.isUnionOrIntersection() ? argType.types : [argType];
+
+  // Checks if the type (or any of the union/intersection types) are either
+  // strings or string literals.
+  const typeContainsString = allTypes.some((tsType) => {
+    return (tsType.getFlags() & ts.TypeFlags.StringLike) !== 0;
+  });
+
+  if (!typeContainsString) return;
+
+  checker.addFailureAtNode(arg, errorMsg);
+}
+
+function sourceFileIsStdLib(sourceFile: ts.SourceFile) {
+  return /lib\.es2015\.(collection|iterable)\.d\.ts$/.test(sourceFile.fileName);
+}
diff --git a/internal/tsetse/runner.ts b/internal/tsetse/runner.ts
index a2b76d4..8e2926a 100644
--- a/internal/tsetse/runner.ts
+++ b/internal/tsetse/runner.ts
@@ -11,6 +11,7 @@
 import {AbstractRule} from './rule';
 import {Rule as BanExpectTruthyPromiseRule} from './rules/ban_expect_truthy_promise_rule';
 import {Rule as BanPromiseAsConditionRule} from './rules/ban_promise_as_condition_rule';
+import {Rule as BanStringInitializedSetsRule} from './rules/ban_string_initialized_sets_rule';
 import {Rule as CheckReturnValueRule} from './rules/check_return_value_rule';
 import {Rule as EqualsNanRule} from './rules/equals_nan_rule';
 import {Rule as MustUsePromisesRule} from './rules/must_use_promises_rule';
@@ -25,6 +26,7 @@
   new BanExpectTruthyPromiseRule(),
   new MustUsePromisesRule(),
   new BanPromiseAsConditionRule(),
+  new BanStringInitializedSetsRule(),
 ];
 
 /**
diff --git a/internal/tsetse/tests/ban_string_initialized_sets/negatives.ts b/internal/tsetse/tests/ban_string_initialized_sets/negatives.ts
new file mode 100644
index 0000000..e9a188a
--- /dev/null
+++ b/internal/tsetse/tests/ban_string_initialized_sets/negatives.ts
@@ -0,0 +1,42 @@
+// tslint:disable
+function emptySet() {
+  const set = new Set();
+}
+
+function noConstructorArgs() {
+  const set = new Set;
+}
+
+function nonStringSet() {
+  const set = new Set([1, 2, 3]);
+}
+
+// This is an allowable way to create a set of strings
+function setOfStrings() {
+  const set = new Set(['abc']);
+}
+
+function setOfChars() {
+  const set = new Set('abc'.split(''));
+}
+
+function explicitlyAllowString() {
+  const set = new Set('abc' as Iterable<string>);
+}
+
+// checks that just a property called 'Set' doesn't trigger the error
+function justAKeyCalledSet(obj: {Set: {new (s: string): any}}) {
+  const set = new obj.Set('abc');
+}
+
+function destructuredConstructorCalledSet(obj: {Set: {new (s: string): any}}) {
+  const {Set} = obj;
+  const set = new Set('abc');
+}
+
+function locallyDeclaredSet() {
+  class Set {
+    constructor(private s: string) {}
+  }
+  const set = new Set('abc');
+}
diff --git a/internal/tsetse/tests/ban_string_initialized_sets/positives.ts b/internal/tsetse/tests/ban_string_initialized_sets/positives.ts
new file mode 100644
index 0000000..a4ec695
--- /dev/null
+++ b/internal/tsetse/tests/ban_string_initialized_sets/positives.ts
@@ -0,0 +1,51 @@
+// tslint:disable
+function setWithStringLiteral() {
+  const set = new Set('abc');
+}
+
+function setWithStringVariable(s: string) {
+  const set = new Set(s);
+}
+
+function setWithStringUnionType(s: string|string[]) {
+  const set = new Set(s);
+}
+
+function setWithStringExpression(fn: () => string) {
+  const set = new Set(fn());
+}
+
+function setWithStringExpression2() {
+  const set = new Set(Math.random() < 0.5 ? 'a' : 'b');
+}
+
+type TypeA = string|Set<string>;
+type TypeB = TypeA|(Iterable<string>&IterableIterator<string>);
+function setWithComplexInitializationType(s: TypeB) {
+  const set = new Set(s);
+}
+
+function setWithUnionStringType(s: string&{toString(): string}) {
+  const set = new Set(s);
+}
+
+function setWithLocalAlias() {
+  const TotallyNotASet = Set;
+  const set = new TotallyNotASet('abc');
+}
+
+function setWithMultipleAliases() {
+  const Foo = Set;
+  const Bar = Foo;
+  const Baz = Bar;
+  const set = new Baz('abc');
+}
+
+function setUsingSetConstructorType(ctor: SetConstructor) {
+  const set = new ctor('abc');
+}
+
+type MySet = SetConstructor;
+function setUsingAliasedSetConstructor(ctor: MySet) {
+  const set = new ctor('abc');
+}