General Tips:
-More MEM points does not always mean better.
It's perfectly possible to take down any enemy with only 1 and 2 point functions.
Generally, high MEM functions take a long time to use, so only work well in Plan()
Lower MEM functions are ideal for rapid fire or fighting without using Plan()
This is especially helpful if you may need to use Plan() defensively.
-Plan() can be activated to, well, plan.
It doesn't always need to be used if you don't need the burst of attack power.
You can just turn it on, come up with a strategy, and then turn it off and use functions manually.

Enemy Tips:
Generally speaking these need Plan() to kill effectively:
-Men are the hardest, with their ability to share a buff and spawn VERY damaging Haircuts.
If these show up, you should enter Plan() immediately,
but only attack with it if you see a stealth (grey) version.
-Youngladies are annoying, but not particularly difficult once you get Cull()
Basically just try to drop them in one hit, otherwise remember to clean up the black images.
-Fetches get very dangerous, especially once they get their stun.
Activate Plan() as soon as they hit you, or counter with Crash() to stun them,
and try to kill them before they can Mask().
-Jerks are very tough, and can quickly do large amounts of damage.
Making things worse is that they have boss-type health, with a stopping threshold at 500.
This means they literally cannot be one-shoted.
Just whittle down their health, try to keep your distance.
If grabbed with their Get(), you can Jaunt() out of it. (Might only work in Plan())

Generally speaking these will not need Plan() to kill effectively:
-Cheerleaders can make other enemies invincible, and at higher versions will make themselves invincible as well.
It's best to land Crash() or some other disable when their shield drops, or just one-shot them if possible.
-Cluckers may actually need you to use Plan() to dodge if you don't have Jaunt() equipped.
Just get in close to fight them, and be careful of the high version's disruption. If you step in it during a Plan(), it will execute the Plan() immediately.
-Creeps can be fairly dangerous, but generally you only need to dodge behind them and hit.
-Snapshots can be obnoxious, but not dangerous really.
The jammer they get at high levels is only trouble mixed with Clucker disruption fields, since you can step in to look around, then undo the move in your Plan().

You should not need tips to kill these:
Badcells. Although you can kill the shielded ones much faster with Purge() if you have it.
Weeds. You should kill them if you aren't a one-shotter, as they can heal damaged enemies.

-The stun is generally enough to stunlock one or two enemies.
-The boost in damage is good, but becomes less important later when you get Void()
-This will remain useful through the whole game.
Recommended Combinations:
+Jaunt(): Possibly the best upgrade, the fastfire and ability to use it while Turn() is on cooldown can save you.
+Bounce(): The other best upgrade, since it will stun a group of enemies.
+Get(): Interesting for stunlocks, since it counteracts the normal knockback.

-This is your main attack early on, but gets obsolete fast.
-It has good range, and is a fairly useful upgrade.
-This will lose usefulness as the game goes.
Recommended Combinations:
+Spark(): Creates a good cone of damage, if you're going to use Breach() this is a decent combo.

-Just don't use it as an active.

-Remember that most upgrades activate at the end point, aim accordingly.
-Almost essential for evasion or speed based combat styles.
-It can be used very well as an attack with the right upgrades.
-The most obvious use that comes to mind for this is to escape after a chain of attacks. This is a good idea.
Recommended Combinations:
+Jaunt()+Bounce(): Once this is possible, it will allow you to charge up Turn() very quickly while evading enemies.
+Purge()+Spark(): Generates six sparks and six Purge() parasites, found to be better than the previously listed +Flood()+Purge().
+Breach(): Early on, this is a good way to deal reliable damage while keeping Jaunt() as an active.
+Switch(): Makes sure you don't get attacked the second you Jaunt() somewhere.
+Tap()+Bounce(): Useful to heal, but not the best method.
+Void(): If you have an extra Void(), it can be used here in a Plan() to deal 1.5x damage.

-Excellent as an upgrade, to the point where you should not be using it as an active.
-Also good as a passive, since the shield can block Haircuts later on, which would usually remove almost all your health.

-It's hard to use and gobbles Turn() power, but is very damaging.
-Works best as an upgrade generally.
Recommended Combinations:
+Flood():Generates a damage over time field, and self destructs eventually, removing most of the skill needed to use it.
+Load():Even bigger explosions. By a lot.

-Very useful for early and midgame, where you need to draw off enemies or deal with a large number.
-Its passive can be activated by toggling Plan() on and off if desired, but Kill() isn't going to be your best attack for long.
-Has a lot of different uses.
-Don't forget to push "q" to control it in Plan().
Recommended Combinations:
+Help(): Almost always destroys cells, making it an excellent last hit on youngladies.
+Crash(): Lets the Helper manage stunning enemies, which takes away some pressure in fights.
+Spark(): Creates 2 slightly weaker Helpers, works well with status effects.
+Ping(): A good substitute for +Help(), as it allows it to move fast enough to pick up all the cells with time to spare.
+Cull(): Allows it to use Sic(), which is a fairly high damage function that only works once per Plan().
+Flood(): Could be interesting, but I've never tried it. Gives it a damage dealing aura.
+Mask(): Deals very high backstab, combined with the high Turn() gauge Helpers have, this can do a lot of damage. This is a very effective way to kill Jerks in one Turn().
+Load(): Deals damage in an area, useful for fighting groups of enemies.

-The damage boost is one of the major offensive uses later on.
-Very useful to escape if you don't have Jaunt() as an active.
-The greatest flaw is that it has a 10 second cooldown, so you need to use it carefully.
Recommended Combinations:
+Jaunt(): The main advantage here is that it refills your Turn() before ending, allowing you to use whatever Plan() twice.
+Load(): A favorite of mine, as it deals a large amount of damage in an area around you.
+Switch(): This might be the best way to use Switch(), as all enemies will target the Switch()ed enemies instead of you. A good panic button.
+Void(): Even more damage boost.
+Mask(): Even MORE damage boost.
+Void()+Mask(): Needless amounts of damage boost.

-Only use as upgrade or passive.
-Use as a passive when you don't use Jaunt() as an active.

-Not my favorite, but good for getting some space.
-Generally you don't want to switch too many enemies if you want to do damage.
-Renders targets immune to your attacks and abilities.
Recommened Combinations:
+Cull(): Doubles duration.
+Flood(): A very high power damage field is generated around the effected enemy, good for clearing weak or support enemies.
+Void(): If you're looking for the target to deal damage, 500% is pretty good.

-The strongest attack in the game.
-Very slow to use.
-Throws enemies and dropped cells, which is not ideal.
-Ends the 3xVoid()->Crash()->Mask()->??? combo for thousands of damage.
Recommended Combinations:
+Void(): More damage.
+Get(): Negates the lift, which means you won't fling cells into space.

-If this active has any use, I've yet to see it.
-Thank you to [VEFI] Taren for pointing out a stong build for this!
-Behaves oddly as an upgrade, often adding unmentioned traits or traits only shown in the text description.
-Quite useful as a passive, as it will regenerate health if you aren't charging Turn()
Recommended Upgrades:
+Void()+Get(): Deals high damage and draws in enemies, keeping them away while dealing high damage over time.

-Generally more useful as an upgrade to Jaunt()
-Its damage over time isn't very useful generally
-Its homing ability can be useful if you are having trouble hitting.
Recommended Upgrades:
+Crash(): This will keep the target stunned while it takes damage, and amplify damage done to it.
+Tap(): If you are using this, odds are it's for defensive fighting, so draining health can help.
+Bounce(): Allows Purge() to continue moving after impact.

-Excellent offense/defense.
-Similar in function to Mask()+Load(), with the added benefit of some healing.
-Quite useful with the right upgrades, and good late in the game.
Recommmened Upgrades:
+Tap(): Provides enough lifesteal that you can often just rush enemy groups and spam Tap().
+Crash(): Allows you to fight safely at the close range this requires without Plan().
+Breach(): Turns Tap() into a medium range attack.
+Jaunt(): Makes Tap() very fast firing, which mixes well with other upgrades.
+Switch(): Works well as a panic button, since it heals you somewhat and switches all nearby enemies.
+Void(): Higher damage.
+Get(): Useful for spamming, since Tap() usually has some knockback.
+Load(): Increases range significantly.

-Amplifies damage dealt to specific enemies.
-Can be stacked 3 times for a total of 325% damage.
-Slow cast time.
Recommended Upgrades:
+Load(): Much larger area of effect.
+Spark(): 2 stacks of Void() for one action.
+Void(): Long enough duration to work with out of Turn()
+Crash(): Economizes function space, allowing two damage boosts in one slot.
+Purge(): High damage over time, if you prefer that.
+Get(): Draws in enemies over a huge area, leading into Load() upgraded attacks well.

-Very limited use, although its low Turn() cost means you can use it to set up attacks without moving.
-Deals higher damage at longer range.
-Helpful for counteracting knockback
Recommended Upgrades:
+Bounce(): Allows Get() to hit multiple enemies.
+Switch(): Allows you to drag around enemies and make them fight each other.

I may as well put up my build here that I used in recursion.

Void()+Spark()+Crash()

Mask()+Mask()+Void()

Cull()+Cull()+Load()

Jaunt()+Purge()+Flood()

It's enough to kill anything in the game several times over.
The key elements are just Void(), Mask(), and Cull(), with Jaunt() for evasion.
The rest is just for overkill.

-Nerava