My First Dart Package — flutter_auditor : A CLI Tool for Flutter Project Health

## My First Dart Package — flutter_auditor

For the last few days, I’ve been working on my first Dart package — flutter_auditor, a CLI tool that helps you check your Flutter project’s health in just a few seconds.

🚀 Check it out on pub.dev:
https://pub.dev/packages/flutter_auditor

It runs audits against your project, shows the report directly in the console, and also generates an HTML report.

Have you ever reached the final stage of your app release and suddenly wondered:

“Is my app actually ready for production?”

You start checking everything at the last moment — security, permissions, dependencies, Android and iOS configurations, assets, release settings, and many other things.

Or even worse, you release your app and later discover an issue, or your app gets rejected because of something that could have been caught earlier.

That’s where flutter_auditor comes in.

The idea is simple: instead of discovering these issues at the last moment, why not identify them earlier?

Run an audit, understand what needs attention, fix the issues, and move toward production with more confidence. 🚀

Actually, where did it start?

As a Flutter developer, I’ve learned so many things and faced lots of challenges during development and before releasing apps.

That’s why I decided to create a package where, if we can capture these issues before releasing the app, it can save us a lot of time.

Because finding an issue during development is always better than discovering it at the last moment before release.

Now you might think...

“This type of package already exists, so what’s new in this package?”

Actually, yes, you’re right!

There are already packages and tools that perform similar types of checks.

But the interesting thing about this package is that it’s a full combo.

You can find packages where sometimes they only show Dart warnings or code-related issues.

But in flutter_auditor, we cover multiple areas together.

1. Multiple audits in one tool

The main idea behind flutter_auditor is to bring different types of project-health checks together.

It audits things like:

• Dart and code-related issues
• Android Manifest
• Security
• UnusedDependency
• DependencyHygiene
• Asset & Size
• Android configuration
• iOS configuration
• And many more

Instead of using different tools for different checks, you can get a broader overview of your Flutter project with one CLI tool.

2. More than just Dart code

One thing I wanted to focus on was that a Flutter project is not only about Dart files.

There are also Android and iOS configurations, dependencies, assets, security settings, and release configurations.

So flutter_auditor goes beyond just checking Dart code and also looks at important project-level configurations.

3. Actionable findings

It’s not only about showing that an issue exists.

The audit results provide useful information such as the severity, location, explanation, and suggested fix.

This makes it easier for developers to understand the problem and decide what needs to be fixed.

4. Console + HTML reports

The results are available directly in the console, which is useful for a quick check.

You can also generate an HTML report when you want a more detailed and visual report that can be shared with your team.

5. CI/CD support

Another thing I wanted was to make flutter_auditor useful in the actual development workflow.

You can use it in your CI/CD pipeline and configure it to fail when findings reach a particular severity.

This means project-health checks can become part of your release process.

6. Existing project? Baseline is here

Now some developers might think:

“I’m working on an old project and there are lots of existing issues. How do I know which issues already existed and which ones are new?”

And this is where the baseline feature helps.

In flutter_auditor, there is a flutter_auditor_baseline.json file.

Using the baseline, you can identify pre-existing findings and new findings.

This is very helpful for existing projects because you don't have to fix every old issue immediately.

You can focus on the new issues first and gradually improve the project over time.

7. Ignore known findings

Sometimes, we already know about a particular issue and have decided to fix it later.

For that, flutter_auditor also provides ignore/suppression support.

This allows developers to focus on the issues that matter right now without completely losing track of the project's existing findings.

8. Make development more productive

The idea is not just to find issues, but to make the development and release process more productive.

Instead of manually checking different parts of the project before every release, you can run flutter_auditor and get a quick overview of your project health.

It can help you catch issues earlier, reduce manual checking, and give you more confidence before releasing your app.

And because it can also be used in CI/CD, it can become a part of your regular development workflow rather than just a one-time check.

Conclusion

For me, the idea behind flutter_auditor is simple:

Audit your Flutter project, find potential issues early, understand what needs to be fixed, and save time before releasing the app. 🚀

This is my first Dart package, and I’m still improving it based on real-world use cases and feedback.

I would love to hear your thoughts on the idea, the features, and what other checks you would like to see in flutter_auditor.

Any feedback, suggestions, or ideas are welcome! 💙