diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/CodeAction.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/CodeAction.cs
new file mode 100644
index 000000000..deb0cb17f
--- /dev/null
+++ b/src/PowerShellEditorServices.Protocol/LanguageServer/CodeAction.cs
@@ -0,0 +1,32 @@
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+using Newtonsoft.Json.Linq;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.LanguageServer
+{
+    public class CodeActionRequest
+    {
+        public static readonly
+            RequestType<CodeActionRequest, CodeActionCommand[]> Type =
+            RequestType<CodeActionRequest, CodeActionCommand[]>.Create("textDocument/codeAction");
+
+        public TextDocumentIdentifier TextDocument { get; set; }
+
+        public Range Range { get; set; }
+
+        public CodeActionContext Context { get; set; }
+    }
+
+    public class CodeActionContext
+    {
+        public Diagnostic[] Diagnostics { get; set; }
+    }
+
+    public class CodeActionCommand
+    {
+        public string Title { get; set; }
+
+        public string Command { get; set; }
+
+        public JArray Arguments { get; set; }
+    }
+}
diff --git a/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs b/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs
index 34ba312f8..aeebb411d 100644
--- a/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs
+++ b/src/PowerShellEditorServices.Protocol/LanguageServer/ServerCapabilities.cs
@@ -24,6 +24,8 @@ public class ServerCapabilities
         public bool? DocumentSymbolProvider { get; set; }
 
         public bool? WorkspaceSymbolProvider { get; set; }
+
+        public bool? CodeActionProvider { get; set; }
     }
 
     /// <summary>
diff --git a/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj b/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj
index 64fb6726c..c26ab8381 100644
--- a/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj
+++ b/src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj
@@ -56,6 +56,7 @@
     <Compile Include="DebugAdapter\SetFunctionBreakpointsRequest.cs" />
     <Compile Include="DebugAdapter\SetVariableRequest.cs" />
     <Compile Include="LanguageServer\EditorCommands.cs" />
+    <Compile Include="LanguageServer\CodeAction.cs" />
     <Compile Include="LanguageServer\FindModuleRequest.cs" />
     <Compile Include="LanguageServer\InstallModuleRequest.cs" />
     <Compile Include="LanguageServer\PowerShellVersionRequest.cs" />
@@ -155,7 +156,7 @@
     </PropertyGroup>
     <Error Condition="!Exists('$(SolutionDir)\.nuget\NuGet.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)\.nuget\NuGet.targets'))" />
   </Target>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
   </Target>
diff --git a/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs b/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
index 78cb0c929..fcdf34f10 100644
--- a/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
+++ b/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
@@ -9,6 +9,7 @@
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
 using Microsoft.PowerShell.EditorServices.Session;
 using Microsoft.PowerShell.EditorServices.Utility;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -30,6 +31,8 @@ public class LanguageServer : LanguageServerBase
         private OutputDebouncer outputDebouncer;
         private LanguageServerEditorOperations editorOperations;
         private LanguageServerSettings currentSettings = new LanguageServerSettings();
+        private Dictionary<string, Dictionary<string, MarkerCorrection>> codeActionsPerFile =
+            new Dictionary<string, Dictionary<string, MarkerCorrection>>();
 
         /// <param name="hostDetails">
         /// Provides details about the host application.
@@ -92,6 +95,7 @@ protected override void Initialize()
             this.SetRequestHandler(HoverRequest.Type, this.HandleHoverRequest);
             this.SetRequestHandler(DocumentSymbolRequest.Type, this.HandleDocumentSymbolRequest);
             this.SetRequestHandler(WorkspaceSymbolRequest.Type, this.HandleWorkspaceSymbolRequest);
+            this.SetRequestHandler(CodeActionRequest.Type, this.HandleCodeActionRequest);
 
             this.SetRequestHandler(ShowOnlineHelpRequest.Type, this.HandleShowOnlineHelpRequest);
             this.SetRequestHandler(ExpandAliasRequest.Type, this.HandleExpandAliasRequest);
@@ -146,6 +150,7 @@ await requestContext.SendResult(
                         DocumentSymbolProvider = true,
                         WorkspaceSymbolProvider = true,
                         HoverProvider = true,
+                        CodeActionProvider = true,
                         CompletionProvider = new CompletionOptions
                         {
                             ResolveProvider = true,
@@ -226,17 +231,17 @@ function __Expand-Alias {
     param($targetScript)
 
     [ref]$errors=$null
-    
-    $tokens = [System.Management.Automation.PsParser]::Tokenize($targetScript, $errors).Where({$_.type -eq 'command'}) | 
+
+    $tokens = [System.Management.Automation.PsParser]::Tokenize($targetScript, $errors).Where({$_.type -eq 'command'}) |
                     Sort Start -Descending
 
     foreach ($token in  $tokens) {
         $definition=(Get-Command ('`'+$token.Content) -CommandType Alias -ErrorAction SilentlyContinue).Definition
 
-        if($definition) {        
+        if($definition) {
             $lhs=$targetScript.Substring(0, $token.Start)
             $rhs=$targetScript.Substring($token.Start + $token.Length)
-            
+
             $targetScript=$lhs + $definition + $rhs
        }
     }
@@ -346,13 +351,13 @@ protected async Task HandleDidChangeConfigurationNotification(
             EventContext eventContext)
         {
             bool oldLoadProfiles = this.currentSettings.EnableProfileLoading;
-            bool oldScriptAnalysisEnabled = 
+            bool oldScriptAnalysisEnabled =
                 this.currentSettings.ScriptAnalysis.Enable.HasValue;
             string oldScriptAnalysisSettingsPath =
                 this.currentSettings.ScriptAnalysis.SettingsPath;
 
             this.currentSettings.Update(
-                configChangeParams.Settings.Powershell, 
+                configChangeParams.Settings.Powershell,
                 this.editorSession.Workspace.WorkspacePath);
 
             if (!this.profilesLoaded &&
@@ -386,6 +391,7 @@ protected async Task HandleDidChangeConfigurationNotification(
                         await PublishScriptDiagnostics(
                             scriptFile,
                             emptyAnalysisDiagnostics,
+                            this.codeActionsPerFile,
                             eventContext);
                     }
                 }
@@ -815,6 +821,35 @@ private bool IsQueryMatch(string query, string symbolName)
             return symbolName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
         }
 
+        protected async Task HandleCodeActionRequest(
+            CodeActionRequest codeActionParams,
+            RequestContext<CodeActionCommand[]> requestContext)
+        {
+            MarkerCorrection correction = null;
+            Dictionary<string, MarkerCorrection> markerIndex = null;
+            List<CodeActionCommand> codeActionCommands = new List<CodeActionCommand>();
+
+            if (this.codeActionsPerFile.TryGetValue(codeActionParams.TextDocument.Uri, out markerIndex))
+            {
+                foreach (var diagnostic in codeActionParams.Context.Diagnostics)
+                {
+                    if (markerIndex.TryGetValue(diagnostic.Code, out correction))
+                    {
+                        codeActionCommands.Add(
+                            new CodeActionCommand
+                            {
+                                Title = correction.Name,
+                                Command = "PowerShell.ApplyCodeActionEdits",
+                                Arguments = JArray.FromObject(correction.Edits)
+                            });
+                    }
+                }
+            }
+
+            await requestContext.SendResult(
+                codeActionCommands.ToArray());
+        }
+
         protected Task HandleEvaluateRequest(
             DebugAdapterMessages.EvaluateRequestArguments evaluateParams,
             RequestContext<DebugAdapterMessages.EvaluateResponseBody> requestContext)
@@ -974,6 +1009,7 @@ private Task RunScriptDiagnostics(
                     DelayThenInvokeDiagnostics(
                         750,
                         filesToAnalyze,
+                        this.codeActionsPerFile,
                         editorSession,
                         eventContext,
                         existingRequestCancellation.Token),
@@ -987,6 +1023,7 @@ private Task RunScriptDiagnostics(
         private static async Task DelayThenInvokeDiagnostics(
             int delayMilliseconds,
             ScriptFile[] filesToAnalyze,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
             EditorSession editorSession,
             EventContext eventContext,
             CancellationToken cancellationToken)
@@ -1034,6 +1071,7 @@ private static async Task DelayThenInvokeDiagnostics(
                 await PublishScriptDiagnostics(
                     scriptFile,
                     semanticMarkers,
+                    correctionIndex,
                     eventContext);
             }
         }
@@ -1041,21 +1079,37 @@ await PublishScriptDiagnostics(
         private static async Task PublishScriptDiagnostics(
             ScriptFile scriptFile,
             ScriptFileMarker[] semanticMarkers,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
             EventContext eventContext)
         {
-            var allMarkers = scriptFile.SyntaxMarkers.Concat(semanticMarkers);
+            List<Diagnostic> diagnostics = new List<Diagnostic>();
+
+            // Hold on to any corrections that may need to be applied later
+            Dictionary<string, MarkerCorrection> fileCorrections =
+                new Dictionary<string, MarkerCorrection>();
+
+            foreach (var marker in scriptFile.SyntaxMarkers.Concat(semanticMarkers))
+            {
+                // Does the marker contain a correction?
+                Diagnostic markerDiagnostic = GetDiagnosticFromMarker(marker);
+                if (marker.Correction != null)
+                {
+                    fileCorrections.Add(markerDiagnostic.Code, marker.Correction);
+                }
+
+                diagnostics.Add(markerDiagnostic);
+            }
+
+            correctionIndex[scriptFile.ClientFilePath] = fileCorrections;
 
-            // Always send syntax and semantic errors.  We want to 
+            // Always send syntax and semantic errors.  We want to
             // make sure no out-of-date markers are being displayed.
             await eventContext.SendEvent(
                 PublishDiagnosticsNotification.Type,
                 new PublishDiagnosticsNotification
                 {
                     Uri = scriptFile.ClientFilePath,
-                    Diagnostics =
-                       allMarkers
-                            .Select(GetDiagnosticFromMarker)
-                            .ToArray()
+                    Diagnostics = diagnostics.ToArray()
                 });
         }
 
@@ -1065,6 +1119,7 @@ private static Diagnostic GetDiagnosticFromMarker(ScriptFileMarker scriptFileMar
             {
                 Severity = MapDiagnosticSeverity(scriptFileMarker.Level),
                 Message = scriptFileMarker.Message,
+                Code = Guid.NewGuid().ToString(),
                 Range = new Range
                 {
                     // TODO: What offsets should I use?
@@ -1145,7 +1200,7 @@ private static CompletionItem CreateCompletionItem(
                     if (!completionDetails.ListItemText.Equals(
                             completionDetails.ToolTipText,
                             StringComparison.OrdinalIgnoreCase) &&
-                        !Regex.IsMatch(completionDetails.ToolTipText, 
+                        !Regex.IsMatch(completionDetails.ToolTipText,
                             @"^\s*" + escapedToolTipText + @"\s+\["))
                     {
                         detailString = completionDetails.ToolTipText;
@@ -1158,7 +1213,7 @@ private static CompletionItem CreateCompletionItem(
             // default (with common params at the end). We just need to make sure the default
             // order also be the lexicographical order which we do by prefixig the ListItemText
             // with a leading 0's four digit index.  This would not sort correctly for a list
-            // > 999 parameters but surely we won't have so many items in the "parameter name" 
+            // > 999 parameters but surely we won't have so many items in the "parameter name"
             // completion list. Technically we don't need the ListItemText at all but it may come
             // in handy during debug.
             var sortText = (completionDetails.CompletionType == CompletionType.ParameterName)
diff --git a/src/PowerShellEditorServices/Analysis/AnalysisService.cs b/src/PowerShellEditorServices/Analysis/AnalysisService.cs
index 489518ccd..8bdaffb86 100644
--- a/src/PowerShellEditorServices/Analysis/AnalysisService.cs
+++ b/src/PowerShellEditorServices/Analysis/AnalysisService.cs
@@ -17,7 +17,7 @@
 namespace Microsoft.PowerShell.EditorServices
 {
     /// <summary>
-    /// Provides a high-level service for performing semantic analysis  
+    /// Provides a high-level service for performing semantic analysis
     /// of PowerShell scripts.
     /// </summary>
     public class AnalysisService : IDisposable
@@ -31,15 +31,19 @@ public class AnalysisService : IDisposable
         /// Defines the list of Script Analyzer rules to include by default if
         /// no settings file is specified.
         /// </summary>
-        private static readonly string[] IncludedRules = {
+        private static readonly string[] IncludedRules = new string[]
+        {
+            "PSUseToExportFieldsInManifest",
+            "PSMisleadingBacktick",
+            "PSAvoidUsingCmdletAliases",
             "PSUseApprovedVerbs",
+            "PSAvoidUsingPlainTextForPassword",
             "PSReservedCmdletChar",
             "PSReservedParams",
             "PSShouldProcess",
             "PSMissingModuleManifestField",
             "PSAvoidDefaultValueSwitchParameter",
-            "PSUseDeclaredVarsMoreThanAssigments",
-            "PSMisleadingBacktick",
+            "PSUseDeclaredVarsMoreThanAssigments"
         };
 
         #endregion // Private Fields
@@ -64,7 +68,7 @@ public string SettingsPath
         /// <summary>
         /// Creates an instance of the AnalysisService class.
         /// </summary>
-        /// <param name="consoleHost">An object that implements IConsoleHost in which to write errors/warnings 
+        /// <param name="consoleHost">An object that implements IConsoleHost in which to write errors/warnings
         /// from analyzer.</param>
         /// <param name="settingsPath">Path to a PSScriptAnalyzer settings file.</param>
         public AnalysisService(IConsoleHost consoleHost, string settingsPath = null)
@@ -107,8 +111,8 @@ public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file)
                     Task.Factory.StartNew<ScriptFileMarker[]>(
                         () =>
                         {
-                                return 
-                                     GetDiagnosticRecords(file) 
+                                return
+                                     GetDiagnosticRecords(file)
                                     .Select(ScriptFileMarker.FromDiagnosticRecord)
                                     .ToArray();
                         },
diff --git a/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs b/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs
index 1d195729a..af6638fbf 100644
--- a/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs
+++ b/src/PowerShellEditorServices/Workspace/ScriptFileMarker.cs
@@ -6,10 +6,19 @@
 using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Management.Automation;
+using System.Collections.Generic;
+using System.Linq;
 using System.Management.Automation.Language;
 
 namespace Microsoft.PowerShell.EditorServices
 {
+    public class MarkerCorrection
+    {
+        public string Name { get; set; }
+
+        public ScriptRegion[] Edits { get; set; }
+    }
+
     /// <summary>
     /// Defines the message level of a script file marker.
     /// </summary>
@@ -55,6 +64,8 @@ public class ScriptFileMarker
         /// </summary>
         public ScriptRegion ScriptRegion { get; set; }
 
+        public MarkerCorrection Correction { get; set; }
+
         #endregion
 
         #region Public Methods
@@ -72,7 +83,7 @@ internal static ScriptFileMarker FromParseError(
             };
         }
         private static string GetIfExistsString(PSObject psobj, string memberName)
-        {            
+        {
             if (psobj.Members.Match(memberName).Count > 0)
             {
                 return psobj.Members[memberName].Value != null ? (string)psobj.Members[memberName].Value : "";
@@ -80,18 +91,60 @@ private static string GetIfExistsString(PSObject psobj, string memberName)
             else
             {
                 return "";
-            }            
+            }
         }
 
         internal static ScriptFileMarker FromDiagnosticRecord(PSObject psObject)
         {
             Validate.IsNotNull("psObject", psObject);
+            MarkerCorrection correction = null;
+
+            // make sure psobject is of type DiagnosticRecord
+            if (!psObject.TypeNames.Contains(
+                    "Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic.DiagnosticRecord",
+                    StringComparer.OrdinalIgnoreCase))
+            {
+                throw new ArgumentException("Input PSObject must of DiagnosticRecord type.");
+            }
+
+            // casting psobject to dynamic allows us to access
+            // the diagnostic record's properties directly i.e. <instance>.<propertyName>
+            // without having to go through PSObject's Members property.
+            var diagnosticRecord = psObject as dynamic;
+            string ruleName = diagnosticRecord.RuleName as string;
+
+            if (diagnosticRecord.SuggestedCorrections != null)
+            {
+                var suggestedCorrections = diagnosticRecord.SuggestedCorrections as dynamic;
+                List<ScriptRegion> editRegions = new List<ScriptRegion>();
+                string correctionMessage = null;
+                foreach (var suggestedCorrection in suggestedCorrections)
+                {
+                    editRegions.Add(new ScriptRegion
+                    {
+                        File = diagnosticRecord.ScriptPath,
+                        Text = suggestedCorrection.Text,
+                        StartLineNumber = suggestedCorrection.StartLineNumber,
+                        StartColumnNumber = suggestedCorrection.StartColumnNumber,
+                        EndLineNumber = suggestedCorrection.EndLineNumber,
+                        EndColumnNumber = suggestedCorrection.EndColumnNumber
+                    });
+                    correctionMessage = suggestedCorrection.Description;
+                }
+
+                correction = new MarkerCorrection
+                {
+                    Name = correctionMessage == null ? diagnosticRecord.Message : correctionMessage,
+                    Edits = editRegions.ToArray()
+                };
+            }
+
             return new ScriptFileMarker
             {
-                Message = GetIfExistsString(psObject, "Message"),
-                //Level = GetMarkerLevelFromDiagnosticSeverity(GetIfExistsString(psObject, "Severity")),
-                Level = GetMarkerLevelFromDiagnosticSeverity("Warning"),
-                ScriptRegion = ScriptRegion.Create((IScriptExtent)psObject.Members["Extent"].Value)
+                Message = diagnosticRecord.Message as string,
+                Level = GetMarkerLevelFromDiagnosticSeverity((diagnosticRecord.Severity as Enum).ToString()),
+                ScriptRegion = ScriptRegion.Create(diagnosticRecord.Extent as IScriptExtent),
+                Correction = correction
             };
         }