Everyone's raving about Pulumi letting you write 'real code' in Python or Go. They claim it's the ultimate for reusability. Meanwhile, OpenClaw (and its older cousin) just use config files.
Color me skeptical. In my world, 'reusable' means the data engineer who only knows SQL can look at it and get the gist. Not inherit a class hierarchy.
Pulumi's 'real code' means you can write a function. Great. It also means you can write a mess. I've seen 'reusable modules' that are 500 lines of abstracted nonsense to deploy a Cloud Storage bucket. With OpenClaw, it's a flat, explicit config block. You can copy, paste, and tweak it without understanding polymorphism.
Here's the 'reusable' pattern I see in both. Which is actually reusable for a team of mixed skills?
Pulumi (Python):
```python
class GcsBucketComponent(pulumi.ComponentResource):
def __init__(self, name, location="US", **kwargs):
super().__init__('my:modules:GcsBucketComponent', name, None, **kwargs)
self.bucket = storage.Bucket(f"{name}-bucket",
location=location,
opts=pulumi.ResourceOptions(parent=self))
self.register_outputs({"bucket_name": self.bucket.name})
```
OpenClaw (HCL-like):
```hcl
module "standard_gcs_bucket" {
source = "./modules/standard_gcs_bucket"
bucket_id = var.bucket_id
location = var.location
}
```
The Pulumi one requires you to know classes, inheritance, and their component model. The OpenClaw one? You just need to know how to fill in variables. For the 90% of infra that's boring, I'll take the config. Less 'powerful,' more predictable.
SQL is enough