I do not claim any IDE being better than another. These are just reasons I personally like developing in Eclipse more than I like developing in IntelliJ.
I have used both the Eclipse IDE and IntelliJ for quite some time and I cannot deny that both are excellent IDEs. While Eclipse is better for me, this might not be the case for you. This is my subjective opinion and this gist is intended to explain some reasons so I don't have to repeat myself all the time.
As I am (mainly) a Java developer, this applies to Java development specifically but some points may not be specific to Java.
IntelliJ comes in two editions: Community Edition (free) and Ultimate Edition (paid). When comparing Eclipse and IntelliJ, this is (in my experience) often ignored. Some functionality is possible in Eclipse (especially using Eclipse IDE for Enterprise Java Developers which is Free and Open Source as well) which are is available in IntelliJ Ultimate Edition (see the point Enterprise Features).
I am not interested in arguments saying IntelliJ would be better than Eclipse because it would support a feature not available in Eclipse when that feature is actually only available in the paid version. Also, nothing would stop you from contributing that to the Eclipse IDE.
That being said, I need some functionality which would be only available in the (paid) Ultimate Edition if I was using IntelliJ. While I would probably be eligible to get a free license, I wouldn't be allowed to use it for some projects and I don't feel like buying a personal license for an IDE, especially when I could get a free license.
However, I do have access to that kind of functionality when using Eclipse.
When debugging an application in Eclipse, I can see the returned value of a method after stepping out of or over the said method, even if that value is not assigned to a variable. While this might seem like a minor detail, I use that all the time and not having that capability would be annoying to me at best.
Similarly, Hot Code replace just works in Debug mode. When I debug an application, change something and save the file, the changes are applied to the application without me restarting it, explicitely pressing a button, key combination for recompiling it. When using Eclipse, this just works without me having to tweak any flags or anything else.
Eclipse uses its own Java Compiler (The Eclipse Java Compiler). While it is also available with other IDEs, it has some advantages for developing applications.
The Eclipse Platform itself is (in my opinion) far more powerful and extensible than the IntelliJ platform. While I am not particularly good at developing IDE plugins, I do see the difference in potential.
For example, if I had to write IDE support for a new programming language, I would prefer doing that for the Eclipse IDE.
Aside from that, just like there are different JetBrains IDEs, there are different Eclipse packages.
But for Eclipse, I can just start from one package (or just using a new Eclipse Platform installation which is "the absolute minimal IDE") and change what I need/completely customize my Eclipse installation as I like.
Eclipse doesn't require as many resources as IntelliJ (although installing too many plugins might change that but that isn't a problem of Eclipse).
I personally like DBeaver more than I like DataGrip/the Databases view of IntelliJ.
I personally prefer workspace-based IDEs over project-based IDEs as I like to switch between multiple (not necessarily related) projects in the same window.
With Eclipse, I can also organize my projects into "Working Sets" which lets me group together some projects in my workspace. With this, I can only focus on the projects that I am working on while still having more projects in my workspace and quickly switch between working sets if necessary.
With Eclipse, I can freely move views in my layout as I want. I can split some parts into multiple views as I want and even combine them to a single window on another screen. This isn't as easily possible with IntelliJ.
In the past, I was often annoyed by IntelliJ basically being unusable while indexing dependencies. When using Eclipse, I don't need to worry about indexing at all and it is ready as soon as it's started.
In my experience, Eclipse is much more configurable than IntelliJ.
Hidden Features
Many people think certain features are only available in IntellIJ and not in Eclipse. However, this is often not the case. In many cases, those are just not enabled by default. See this video for hints regarding working efficiently using Eclipse.
While I mostly edit pom.xml files as text, Eclipse's Maven POM Editor is really powerful and useful, especially when it comes to looking for certain things.
For example, it has a Dependencies and Dependency Hierarchy tab which can be imagined as interactive versions of the mvn dependency:list and mvn dependency:tree commands respectively while the Dependencies tab also allows for editing dependencies. Similarly, the Effective POM tab tells me about the effective POM (similar to mvn help:effective-pom) in text format which is useful when I want to inspect something about a pom.xml file.
Aside from viewing POM files, I also like how Eclipse handles Maven projects in general. If I have a multi-module Maven project or multiple Maven projects in the same workspace referencing each other (assuming the versions are correctly set up), Eclipse detects projects referencing each other. When I then change something in one project, these changes are applied to the other project immediately without me having to configure it. This can make developing significantly easier.
Eclipse is fully Free and Open Source Software. While IntelliJ has a free Community Edition (which also includes proprietary components), I prefer everything to be Open Source.
In general, I think it is preferable to use Open Source tooling where applicable. The whole development of the Eclipse IDE happens in an Open Source and transparent way at the Eclipse Foundation.
Aside from that, Open Source projects allow people to build their own functionality and contribute it to the original project like I have done with Spring Tools. If I was using IntelliJ, I wouldn't be able to contribute code to the Spring (or similar) tooling I use.
Also, I really think that there should be a viable option for choosing an IDE which is not just controlled by a single company (like JetBrains or Microsoft).
This also leads to many features (e.g. autocompletion of Hibernate queries using JBoss Tools) which would otherways only be available in the Ultimate Edition of IntelliJ being Free and Open Source with Eclipse.
Due to the nature of Eclipse being Free and Open Source Software, it is possible to use parts of the Eclipse Tooling for other projects. For example, there are multiple IDEs building on top of Eclipse for solving specific tasks. Also, the Java Tooling of Visual Studio Code uses tooling of the JDT (from the Eclipse IDE).
The Eclipse IDE is the only major IDE I know about which is independent and not controlled by a single company. IntelliJ is developed by JetBrains but the Eclipse IDE is created under the umbrella of the Eclipse Foundation. While it is possible for various organizations to influence and contribute to Eclipse tooling and the IDE, there is not a single, profit-oriented company having control over what happens with it.
To be honest, I don't want to be fully dependent on some company when it comes to the IDE I use.
In my opinion, it is important to have major independent Open Source tooling and not let a single company dominate everything in that regard. Also, the Java support of Visual Studio Code is built on Eclipse tooling (JDT-LS) making it depend on the Eclipse IDE project.
Nice.