When it comes to making your JSON outputs clean and avoiding clutter from unwanted fields, using the built-in `json` module can certainly be a bit tricky. You mentioned using `__dict__`, but as you’ve noticed, that can pull in everything, including those pesky extra fields.

One approach you might find handy is using Python’s dataclasses. By defining your class as a dataclass, you can use the `asdict` function from the `dataclasses` module, which allows you to convert your dataclass instance to a dictionary. From there, you can create a custom function that filters out certain fields before passing it to `json.dumps`. Here’s a quick example:

from dataclasses import dataclass, asdict
import json

@dataclass
class MyClass:
    id: int
    name: str
    secret: str  # This is the field you want to exclude.

def to_json(obj):
    data = asdict(obj)
    data.pop('secret', None)  # Remove the 'secret' field before serialization
    return json.dumps(data)

my_obj = MyClass(id=1, name='Example', secret='hidden')
json_output = to_json(my_obj)
print(json_output)  # This will print: {"id": 1, "name": "Example"}
    

This way, you keep it simple and avoid a ton of boilerplate. You can also wrap the `pop` line in a loop if you need to remove multiple fields. Another very cool option is using libraries like Marshmallow or Pydantic. They both provide a way to define which fields to include/exclude in the serialization process and can handle nested structures quite elegantly.

However, if you’re just working on a smaller project, bringing in a third-party library might feel like overkill. But if you plan on scaling up your project later or working with complex validation and serialization, they could save you a lot of headaches. So, weigh your options based on your project’s complexity.

Ultimately, it’s about finding a balance between simplicity and maintainability. Hopefully, one of these methods clicks for you!