I've successfully built a game where the main content and gameplay were implemented via rules similar to this.
It was a visual novel/narrative game where most of the logic hinged on when to trigger particular scenes, so I wanted this to be exposed in data and easy for the narrative designers/writers on my team to control.
I used a fuzzy pattern matching system based on this Valve talk to select the next event to fire.
Each event was a short script (containing dialogue, variable updates, basic conditional logic, or triggers for chaining to the next rule) written in a simple scripting language. The scripts and rules would be compiled to bytecode and run in a fairly basic virtual machine.
This let my core game code stay very lean:
Initialize state variables to new game state
Fire rule matching "new game" event to let writers add to the startup state
Based on the state following the last event, update state variables
(simple things like advancing a time counter that I might want to happen automatically, rather than write into every single event, or advancing the phase of play between intro - action - result stages)
Look for the next rule to match based on the current state, and fire its event
Loop 3 & 4 until the victory or game over states are hit
This approach gave the writers a ton of flexibility, but also a ton of responsibility to ensure their rules & events supported the game structure & all contingencies. We needed to include a few very permissive rules to ensure the game would never stall with no further matching events to play. And reasoning about the possibility space of the game, or how often/how soon particular scenes might fire became quite complicated.
So far the system has been reasonably successful for its goals, I would say, but it's not a universal solution or ideal for every game.
Based on this, I can say that a rule-matching core works for at least some class of game. Whether it's the right choice for your game is something you'll need to evaluate based on your own plans & goals.