This blog post is all about: why I gave up on Grammarly, what's the difference between ReSharper-aided Visual Studio and Sublime Text or Vim, did VS cripple generations of software developers and why I'm skeptical of modern IDEs (hint: they are not solving the problems they should be solving ...)

I do write a lot. Mainly in English.

I've got a lot of practice, so in my case, the process of writing is quite fluent, but it still takes some time - structuring thoughts, adding content, proof-reading, polishing, etc. That's why all the ideas or tools that could help me save even single minutes (per post) are worth their weight in gold. In June 2018 I discovered a bunch of tools that could be helpful (e.g., Hemingway) - in the end, I've decided to use Grammarly, which gives lovely, instantaneous feedback on grammar, punctuation and stylistic (mainly repetitions, but still) errors.

I was quite happy with the tool - nicely integrated, discreet enough and apparently: really saves time.

But recently (1-2 months ago) I've started to notice a problem ... Until now I never had any issues with spelling or grammar - neither in Polish nor in English. Few months have passed & ... it seems that I do make MORE mistakes than I did before, I'm uncertain (about spelling) MORE frequently than before (in case of some words: notoriously). In theory, it's not an issue, because these are getting fixed immediately (thanks to Grammarly), but apparently, I've "outsourced too much" - instead of having an automated secondary check,  I've started relying on it so much that my own skill has degenerated.

I consider writing correctly (on my own) my "core", "primary" skill - I find it absolutely essential. That's why Grammarly has to go, I'll have to manage w/o it (shrug)

Programming "muscle"

But should you care? And why?

Last year I changed work environment - previously I've worked mainly with .NET Software Engineers who were writing C# code using Visual Studio & (non-surprisingly as sometimes it's considered as de facto standard) ReSharper. Currently, my teams use dynamically-typed languages: JavaScript, Ruby & Elixir. Fragmentation of my fellow engineers' preferred IDEs/code editors is quite high: most favorite picks are very lightweight (far closer to being a text editor than a fully-fledged IDE) Vim, Sublime, Atom & VSCode.

When it comes to writing code - is it a significant change or not? To be honest, it's like a completely different discipline, e.g.:

  • ReSharper pro-actively suggests you "improvements" & can apply them in context (so you don't have to do ANYTHING except for hitting Alt+Enter), while in Vim or Sublime snippets are "dumb" - pre-defined static content is inserted after you type a macro keystroke
  • ReSharper smartly extracts interfaces, properties or methods, fixes pre-set conventions - nothing like that is available in lightweight text editors (like Vim, Sublime or VSCode)
  • Visual Studio has just been upgraded with IntelliCode - ML is suggesting (based on analyzed standard libraries & your own code) your next keystrokes on-the-go; obviously - Vim, Atom or Sublime have nothing like that

It seems like Visual Studio & ReSharper are making developers' life easier & more convenient, while also speeding up the code-work.

But my question is - doesn't it go too far?

Will developers ... keep developing?

To be more precise:

  1. will developers preserve the ability to ... code? In other words - if a developer can't declare (doesn't know/has forgotten syntax ...) a delegate, lambda or an event handler - is it a problem or not?
  2. if extensions (AI-based or not, doesn't matter) do the heavy-lifting when it comes to code analysis, will developers still pay attention to detail?
  3. if IntelliCode suggests the most probable lexemes (lexical elements) won't it create some sort of "auto-pilot" mode & limit the engineers' creativity/insight?

I agree that code semantics is MUCH more important than basic language syntax. I agree that syntax needed to create a delegate, lambda or whatever can be easily googled & knowing it is NOT the main value of the hired engineer. I agree that tools like IntelliSense or IntelliCode can undoubtedly speed up development when it comes to efficiency (not necessarily effectiveness though!)


A programming language is an example of a low-level tool - you use it to express higher-level, design-based concepts that form the business solutions, so its (language's) usage HAS to be intuitive, natural, even "subliminal". Practicing the usage of language-level constructs is supposed to be your everyday-kata because the more fluent in it you are, the more you can squish out of the language & the easier it will be to do wonders on the higher levels of abstraction.

I'm skeptical of modern IDEs

Some of you may sneer at these comments & find them an exaggeration - let's assume that in spite of all these tools an experienced developer like you can keep & preserve a high language proficiency. But what about juniors (especially neophytes) - for whom their first contact with the language will be via tools like Visual Studio with IntelliCode and ReSharper?

Will they be C# developers? Or maybe Visual Studio operators who barely know the language they see on the screen (because IDE guides them by hand)?

Automating the tedious (repetitive) tasks? YES
Fast feedback on violating conventions or good practices (e.g. with red underline)? YES
Snippets libraries, "dumb" macros? Still, YES

But all the actual knowledge/creative work still (IMHO) requires sane, human judgment & engineering common-sense. I dare say that we, humans, haven't yet truly mastered building software systems that are long-term sustainable: my suggestion for us all it to focus on simplifying the tool-sets and adjusting them to be more malleable, NOT on building bots & assistants that become necessary to navigate across the over-complicated software development ecosystem.

You may call me old-fashioned, but now I'll be getting back to my ol' good Emacs + Spacemacs combo :)

Share this post